Sunday, May 16, 2021

Prediksi & Klasifikasi Penyakit Diabetes

doditsuprianto 4:55 AM

Berikut ini adalah cerita tentang klasifikasi penyakit diabetes, dimana diabetes.csv diperoleh dari Kaggle (https://www.kaggle.com/uciml/pima-indians-diabetes-database). Klasifikasi menggunakan beberapa pemodelan machine learning, antara lain:

K Neighbors Classifier (KNN)
Support Vector Classifier
Decision Tree Classifier
Random Forest Classifier
Boosting

Ada Boost Classifier
Gradient Boosting Classifier
Stochastic Gradient Boosting (SGB)
Cat Boost Classifier
Extreme Gradient Boosting (XGBoost)

Gradient Boosting Classifier
Stacking (semacam cascading atau kombinasi pemodelan yang dilakukan secara bertahap dan berantai)

Dari hasil pengujian model klasifikasi, nanti akan dibandingkan sisi akurasi pengujian dari tiap model yang ditampilkan dalam grafis histogram. Dari situ akan tampak pemodelan mana yang paling baik untuk mengklasifikasi penyakit diabetes berdasarkan fitur:

Pregnancies
Glucose
BloodPressure
SkinThickness
Insulin
BMI
DiabetesPedigreeFunction
Age

Saya tidak menjelaskan secara detil bagaimana cara kerja setiap model karena akan membutuhkan penulisan panjang. Oleh karena itu pembaca diharapkan menggali lebih dalam setiap model yang diujikan.

Kode program dan dataset diabetes.csv dapat diunduh di:

Diabetes.csv (https://drive.google.com/file/d/1iEYev4Ut4FfFVsVREcwgoDOWuHaO2bQ4/view?usp=sharing)
Kode program klasifikasi (https://colab.research.google.com/drive/1RdFAUITYe0wScM-4nVU5aj8yTql9vHfg?usp=sharing)

Adapun ilustrasi hasil dan proses adalah sebagai berikut

# me-mounting/menghubungkan colab dengan data di google drive
# sesuaian dengan punya kalian
from google.colab import drive
drive.mount('/content/gdrive')

# impor library yang dubutuhkan
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings

warnings.filterwarnings('ignore')

sns.set()    

%matplotlib inline

# memabaca data diabetes.csv dari google drive dengan path yang sesuai
data = pd.read_csv('gdrive/MyDrive/Belajar Mesin Learning 2021/Diabetes/diabetes.csv')

# cuplikasn dataset diabetes.cv
data.head()

# menampilkan ringkasan data diabetes
data.describe()

Tampaknya tidak ada nilai yang hilang dalam data kami. Kita lihat sebaran datanya:

# menampilkan distribusi data untuk setiap kolom.
plt.figure(figsize = (15,25))
plotnumber = 1

for column in data:
  if plotnumber <=9:
    ax = plt.subplot(3,3,plotnumber)
    sns.distplot(data[column])
    plt.xlabel(column, fontsize=15)

  plotnumber += 1

plt.show()

Dari grafis di atas dapat dilihat bahwa ada beberapa kecondongan dalam data.

Juga, kita dapat melihat bahwa Glukosa, Insulin, Ketebalan Kulit, BMI dan Tekanan Darah yang nilainya 0. Itu tidak mungkin. Kita dapat menghapus data tersebut atau menggantinya dengan nilai rata-rata masing-masing.

# mengganti nilai nol dengan rata-rata kolom
data['BMI'] = data['BMI'].replace(0, data['BMI'].mean())
data['BloodPressure'] = data['BloodPressure'].replace(0, data['BloodPressure'].mean())
data['Glucose'] = data['Glucose'].replace(0, data['Glucose'].mean())
data['Insulin'] = data['Insulin'].replace(0, data['Insulin'].mean())
data['SkinThickness'] = data['SkinThickness'].replace(0, data['SkinThickness'].mean())

# memeriksa kembali distribusi data
plt.figure(figsize = (15, 25))
plotnumber = 1

for column in data:
  if plotnumber <= 9:
    ax = plt.subplot(3, 3, plotnumber)
    sns.distplot(data[column])
    plt.xlabel(column, fontsize = 15)

  plotnumber += 1

plt.show

Sekarang kita telah menangani nilai 0 dan data terlihat lebih baik, namun masih terdapat pencilan(outlier) di beberapa kolom. Mari kita tangani mereka.

Diterjemahkan dari bahasa Inggris-Dalam statistik, pencilan adalah titik data yang berbeda secara signifikan dari pengamatan lain. Pencilan mungkin disebabkan oleh variabilitas dalam pengukuran atau mungkin menunjukkan kesalahan eksperimental; yang terakhir kadang-kadang dikecualikan dari kumpulan data

fig, ax = plt.subplots(figsize = (15, 10))
sns.boxplot(data = data, width = 0.5, ax = ax, fliersize = 3)
plt.show

outlier = data['Pregnancies'].quantile(0.98)
# menghapus 2% data teratas dari kolom kehamilan
data = data[data['Pregnancies'] < outlier]

outlier = data['BMI'].quantile(0.99)
# menghapus 1% data teratas dari kolom BMI
data = data[data['BMI'] < outlier]

outlier = data['SkinThickness'].quantile(0.99)
# menghapus 1% data teratas dari kolom SkinThickness
data = data[data['SkinThickness'] < outlier]

outlier = data['Insulin'].quantile(0.95)
# menghapus 5% data teratas dari kolom Insulin
data = data[data['Insulin'] < outlier]

outlier = data['DiabetesPedigreeFunction'].quantile(0.99)
# menghapus 1% data teratas dari kolom DiabetesPedigreeFunction
data = data[data['DiabetesPedigreeFunction'] < outlier]

outlier = data['Age'].quantile(0.99)
# menghapus 1% data teratas dari kolom Usia
data = data[data['Age'] < outlier]

# memeriksa kembali distribusi data
plt.figure(figsize = (15, 25))
plotnumber = 1

for column in data:
    if plotnumber <= 9:
        ax = plt.subplot(3, 3, plotnumber)
        sns.distplot(data[column])
        plt.xlabel(column, fontsize = 15)
        
    plotnumber += 1
plt.show()

dataframe.corr() digunakan untuk mencari korelasi berpasangan dari semua kolom di dataframe. Nilai na apa pun secara otomatis dikecualikan. Untuk setiap kolom tipe data non-numerik dalam dataframe itu diabaikan.

Pearson correlation coefficient between two variables X and Y can be calculated using the following formula. X bar is mean value of X and Y bar is mean value of Y. Xi and Yi represents different values of X and Y.

plt.figure(figsize = (16, 8))

corr = data.corr()
mask = np.triu(np.ones_like(corr, dtype = bool))

sns.heatmap(corr, mask=mask, annot=True, fmt='.2g', linewidths=1)
plt.show()

X = data.drop(columns=['Outcome'])
y = data['Outcome']

# membagi data menjadi data pengujian dan pelatihan.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=0)

Standarisasi fitur dengan menghilangkan mean dan menskalakan ke unit varians

Skor standar sampel x dihitung sebagai:

z = (x - u) / s

di mana u adalah mean dari sampel pelatihan atau nol jika with_mean = False, dan s adalah deviasi standar dari sampel pelatihan atau satu jika with_std = False.

# menskalakan data bagian dari tuning
# ref: https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Regresion Logistic Classifier

# fitting data to model
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

lr = LogisticRegression()

lr.fit(X_train, y_train)

y_pred = lr.predict(X_test)

lr_train_acc = accuracy_score(y_train, lr.predict(X_train))
lr_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi pelatihan model regresi logistik adalah {lr_train_acc}')
print(f'Akurasi pengujian model regresi logistik adalah {lr_test_acc}')

Akurasi pelatihan model regresi logistik adalah 0.805940594059406 Akurasi pengujian model regresi logistik adalah 0.7751479289940828

Confusion Matrix adalah pengukuran performa untuk masalah klasifikasi machine learning dimana keluaran dapat berupa dua kelas atau lebih. Confusion Matrix adalah tabel dengan 4 kombinasi berbeda dari nilai prediksi dan nilai aktual. Ada empat istilah yang merupakan representasi hasil proses klasifikasi pada confusion matrix yaitu True Positif, True Negatif, False Positif, dan False Negatif

# confusion matrix 
confusion_matrix(y_test, y_pred)

array([[106, 11], [ 27, 25]])

Report Classification (Laporan Klasifikasi)

digunakan untuk mengukur kualitas prediksi dari algoritma klasifikasi. Berapa banyak prediksi yang benar dan berapa banyak yang salah. Lebih khusus lagi, Positif Benar, Positif Palsu, Negatif Benar dan Negatif Palsu digunakan untuk memprediksi metrik laporan klasifikasi.

Laporan tersebut menunjukkan presisi, perolehan, dan skor f1 metrik klasifikasi utama pada basis per kelas. Metrik dihitung dengan menggunakan positif benar dan salah, negatif benar dan salah. Positif dan negatif dalam hal ini adalah nama generik untuk kelas yang diprediksi. Ada empat cara untuk memeriksa apakah prediksi tersebut benar atau salah:

TN / True Negative: ketika sebuah kasus negatif dan diprediksi negatif
TP / True Positive: saat kasus positif dan diprediksi positif
FN / False Negative: ketika suatu kasus positif tetapi diprediksi negatif
FP / False Positive: ketika suatu kasus negatif tetapi diprediksi positif

Precision - Berapa persen dari prediksi Anda yang benar?

Presisi adalah kemampuan pengklasifikasi untuk tidak memberi label pada instance positif yang sebenarnya negatif. Untuk setiap kelas, ini didefinisikan sebagai rasio positif benar dengan jumlah positif benar dan salah.

TP - Positif Benar
FP - Positif Palsu
Precision - Akurasi prediksi positif.
Precision = TP / (TP + FP)

Recall - Berapa persen dari kasus positif yang Anda tangkap?

Recall adalah kemampuan pengklasifikasi untuk menemukan semua contoh positif. Untuk setiap kelas, ini didefinisikan sebagai rasio positif benar dengan jumlah positif benar dan negatif palsu.

FN - Negatif Palsu
Recall: Fraksi positif yang diidentifikasi dengan benar.
Recall = TP / (TP + FN)

Skor F1 - Berapa persen dari prediksi positif yang benar?

Skor F1 adalah rata-rata precision dan recall harmonik tertimbang sehingga skor terbaik adalah 1.0 dan yang terburuk adalah 0.0. Secara umum, skor F1 lebih rendah daripada ukuran akurasi karena mereka menanamkan precision dan recall ke dalam penghitungannya. Sebagai aturan praktis, rata-rata tertimbang F1 harus digunakan untuk membandingkan model pengklasifikasi, bukan akurasi global.

Skor F1 = 2 * (Recall * Precision) / (Recall + Precision)

# classification report
print(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.80 0.91 0.85 117 1 0.69 0.48 0.57 52 accuracy 0.78 169 macro avg 0.75 0.69 0.71 169 weighted avg 0.77 0.78 0.76 169

K Neighbors Classifier (KNN)

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier()
knn.fit(X_train, y_train)

y_pred = knn.predict(X_test)

knn_train_acc = accuracy_score(y_train, knn.predict(X_train))
knn_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi pelatihan model KNN adalah {knn_train_acc}')
print(f'Akurasi pengujian model KNN adalah {knn_test_acc}')

Akurasi pelatihan model KNN adalah 0.8376237623762376 Akurasi pengujian model KNN adalah 0.7514792899408284

confusion_matrix(y_test, y_pred)

array([[103, 14], [ 28, 24]])

print(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.79 0.88 0.83 117 1 0.63 0.46 0.53 52 accuracy 0.75 169 macro avg 0.71 0.67 0.68 169 weighted avg 0.74 0.75 0.74 169

Support Vector Classifier

from sklearn.svm import SVC

svc = SVC()
svc.fit(X_train, y_train)

y_pred = svc.predict(X_test)

svc_train_acc = accuracy_score(y_train, svc.predict(X_train))
svc_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi pelatihan model SVC adalah {svc_train_acc}')
print(f'Akurasi uji model SVC adalah {svc_test_acc}')

Akurasi pelatihan model SVC adalah 0.8534653465346534 Akurasi uji model SVC adalah 0.7633136094674556

confusion_matrix(y_test, y_pred)

array([[101, 16], [ 24, 28]])

print(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.81 0.86 0.83 117 1 0.64 0.54 0.58 52 accuracy 0.76 169 macro avg 0.72 0.70 0.71 169 weighted avg 0.76 0.76 0.76 169

Decision Tree Classifier

from sklearn.tree import DecisionTreeClassifier

dtc = DecisionTreeClassifier()
dtc.fit(X_train, y_train)

y_pred = dtc.predict(X_test)

dtc_train_acc = accuracy_score(y_train, dtc.predict(X_train))
dtc_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi pelatihan model Decision Tree adalah {dtc_train_acc}')
print(f'Akurasi uji model Decision Tree adalah {dtc_test_acc}')

Akurasi pelatihan model Decision Tree adalah 1.0 Akurasi uji model Decision Tree adalah 0.7396449704142012

confusion_matrix(y_test, y_pred)

array([[95, 22], [22, 30]])

print(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.81 0.81 0.81 117 1 0.58 0.58 0.58 52 accuracy 0.74 169 macro avg 0.69 0.69 0.69 169 weighted avg 0.74 0.74 0.74 169

# hyper parameter tuning

from sklearn.model_selection import GridSearchCV

grid_params = {
    'criterion' : ['gini', 'entropy'],
    'max_depth' : [3, 5, 7, 10],
    'min_samples_split' : range(2, 10, 1),
    'min_samples_leaf' : range(2, 10, 1)
}

grid_search = GridSearchCV(dtc, grid_params, cv = 5, n_jobs = -1, verbose = 1)
grid_search.fit(X_train, y_train)

# best parameters and best score

print(grid_search.best_params_)
print(grid_search.best_score_)

{'criterion': 'entropy', 'max_depth': 5, 'min_samples_leaf': 9, 'min_samples_split': 3} 0.7683168316831683

dtc = grid_search.best_estimator_

y_pred = dtc.predict(X_test)

dtc_train_acc = accuracy_score(y_train, dtc.predict(X_train))
dtc_test_acc = accuracy_score(y_test, y_pred)

print(f"Akurasi pelatihan model Decesion Tree adalah {dtc_train_acc}")
print(f"Akurasi pengujian model Decesion Tree adalah {dtc_test_acc}")

Akurasi pelatihan model Decesion Tree adalah 0.80990099009901 Akurasi pengujian model Decesion Tree adalah 0.7041420118343196

# confusion matrix

confusion_matrix(y_test, y_pred)

array([[85, 32], [18, 34]])

# classification report

print(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.83 0.73 0.77 117 1 0.52 0.65 0.58 52 accuracy 0.70 169 macro avg 0.67 0.69 0.67 169 weighted avg 0.73 0.70 0.71 169

Random Forest Classifier

from sklearn.ensemble import RandomForestClassifier

rand_clf = RandomForestClassifier(criterion='gini', max_depth=3, max_features='sqrt', min_samples_leaf=2, min_samples_split=4, n_estimators=180)
rand_clf.fit(X_train, y_train)

y_pred = rand_clf.predict(X_test)

rand_clf_train_acc = accuracy_score(y_train, rand_clf.predict(X_train))
rand_clf_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi latih model random forest adalah {rand_clf_train_acc}')
print(f'Akurasi uji model random forest adalah {rand_clf_test_acc}')

Akurasi latih model random forest adalah 0.8118811881188119 Akurasi uji model random forest adalah 0.7810650887573964

confusion_matrix(y_test, y_pred)

array([[108, 9], [ 28, 24]])

print(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.79 0.92 0.85 117 1 0.73 0.46 0.56 52 accuracy 0.78 169 macro avg 0.76 0.69 0.71 169 weighted avg 0.77 0.78 0.76 169

Boosting

Ada Boost Classifier

from sklearn.ensemble import AdaBoostClassifier

ada = AdaBoostClassifier(base_estimator = dtc)

parameters = {
    'n_estimators' : [50, 70, 90, 120, 180, 200],
    'learning_rate' : [0.001, 0.01, 0.1, 1, 10],
    'algorithm' : ['SAMME', 'SAMME.R']
}

grid_search = GridSearchCV(ada, parameters, n_jobs=-1, cv=5, verbose=1)
grid_search.fit(X_train, y_train)

{'algorithm': 'SAMME', 'learning_rate': 0.001, 'n_estimators': 120} 0.7742574257425743

ada = AdaBoostClassifier(base_estimator = dtc, algorithm='SAMME', learning_rate=0.01, n_estimators=120)
ada.fit(X_train, y_train)

ada_train_acc = accuracy_score(y_train, ada.predict(X_train))
ada_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi pelatihan model Ada Boost adalah {ada_train_acc}')
print(f'Akurasi pengujian model Ada Boost adalah {ada_test_acc}')

Akurasi pelatihan model Ada Boost adalah 0.8495049504950495 Akurasi pengujian model Ada Boost adalah 0.7810650887573964

confusion_matrix(y_test, y_pred)

array([[108, 9], [ 28, 24]])

print(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.79 0.92 0.85 117 1 0.73 0.46 0.56 52 accuracy 0.78 169 macro avg 0.76 0.69 0.71 169 weighted avg 0.77 0.78 0.76 169

Gradient Boosting Classifier

from sklearn.ensemble import GradientBoostingClassifier

gb = GradientBoostingClassifier()

parameters = {
    'loss': ['deviance', 'exponential'],
    'learning_rate': [0.001, 0.1, 1, 10],
    'n_estimators': [100, 150, 180, 200]
}

grid_search = GridSearchCV(gb, parameters, cv=5, n_jobs=-1, verbose=1)
grid_search.fit(X_train, y_train)

# best parameter and best score

print(grid_search.best_params_)
print(grid_search.best_score_)

{'learning_rate': 0.1, 'loss': 'deviance', 'n_estimators': 150} 0.7683168316831683

gb = GradientBoostingClassifier(learning_rate=0.1, loss='deviance', n_estimators=150)
gb.fit(X_train, y_train)

y_pred = gb.predict(X_test)

gb_train_acc = accuracy_score(y_train, gb.predict(X_train))
gb_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi pelatihan klasifikasi Gradient Boosting adalah {gb_train_acc}')
print(f'Akurasi pengujian klasifikasi Gradient Boosting adalah {gb_test_acc}')

Akurasi pelatihan klasifikasi Gradient Boosting adalah 0.9801980198019802 Akurasi pengujian klasifikasi Gradient Boosting adalah 0.7810650887573964

confusion_matrix(y_test, y_pred)

array([[103, 14], [ 23, 29]])

rint(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.82 0.88 0.85 117 1 0.67 0.56 0.61 52 accuracy 0.78 169 macro avg 0.75 0.72 0.73 169 weighted avg 0.77 0.78 0.77 169

Stochastic Gradient Boosting (SGB)

sgbc  = GradientBoostingClassifier(learning_rate=0.1, subsample=0.9, max_features=0.75, loss='deviance', n_estimators=100)

sgbc.fit(X_train, y_train)

y_pred = sgbc.predict(X_test)

sgbc_train_acc = accuracy_score(y_train, sgbc.predict(X_train))
sgbc_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi pelatihan model SGB adalah {sgbc_train_acc}')
print(f'Akurasi pengujian model SGB adalah {sgbc_test_acc}')

Akurasi pelatihan model SGB adalah 0.9504950495049505 Akurasi pengujian model SGB adalah 0.7810650887573964

confusion_matrix(y_test, y_pred)

array([[104, 13], [ 24, 28]])

print(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.81 0.89 0.85 117 1 0.68 0.54 0.60 52 accuracy 0.78 169 macro avg 0.75 0.71 0.73 169 weighted avg 0.77 0.78 0.77 169

Cat Boost Classifier

Karena pada Colab Jupyter Notebook belum tersedia library Cat Boost Classifier maka kita perlu menginstallnya dengan perintah pip sebagai berikut:

pip install catboost

from catboost import CatBoostClassifier

cat = CatBoostClassifier(iterations=30, learning_rate=0.1)
cat.fit(X_train, y_train)

y_pred = cat.predict(X_test)

0: learn: 0.6685258 total: 1.79ms remaining: 51.9ms 1: learn: 0.6473668 total: 4.01ms remaining: 56.1ms 2: learn: 0.6302430 total: 5.67ms remaining: 51.1ms 3: learn: 0.6100358 total: 7.66ms remaining: 49.8ms 4: learn: 0.5929452 total: 9.68ms remaining: 48.4ms 5: learn: 0.5788837 total: 12.6ms remaining: 50.3ms 6: learn: 0.5665110 total: 14.1ms remaining: 46.2ms 7: learn: 0.5560446 total: 16ms remaining: 43.9ms 8: learn: 0.5450193 total: 17.5ms remaining: 40.8ms 9: learn: 0.5351082 total: 19.8ms remaining: 39.6ms 10: learn: 0.5259947 total: 23.1ms remaining: 40ms 11: learn: 0.5173567 total: 28.9ms remaining: 43.3ms 12: learn: 0.5079918 total: 32.2ms remaining: 42.2ms 13: learn: 0.4997189 total: 34.2ms remaining: 39.1ms 14: learn: 0.4923370 total: 37ms remaining: 37ms 15: learn: 0.4855266 total: 39ms remaining: 34.1ms 16: learn: 0.4792526 total: 40.5ms remaining: 31ms 17: learn: 0.4727197 total: 41.9ms remaining: 28ms 18: learn: 0.4668655 total: 43.4ms remaining: 25.1ms 19: learn: 0.4619647 total: 44.9ms remaining: 22.5ms 20: learn: 0.4576674 total: 46.4ms remaining: 19.9ms 21: learn: 0.4539130 total: 47.6ms remaining: 17.3ms 22: learn: 0.4489922 total: 49ms remaining: 14.9ms 23: learn: 0.4450120 total: 50.5ms remaining: 12.6ms 24: learn: 0.4414600 total: 51.9ms remaining: 10.4ms 25: learn: 0.4373530 total: 53.4ms remaining: 8.22ms 26: learn: 0.4319888 total: 55.3ms remaining: 6.14ms 27: learn: 0.4281363 total: 57.2ms remaining: 4.08ms 28: learn: 0.4251036 total: 58.8ms remaining: 2.03ms 29: learn: 0.4222732 total: 60.3ms remaining: 0us

cat_train_acc = accuracy_score(y_train, cat.predict(X_train))
cat_test_acc = accuracy_score(y_test, y_pred)

print(f"Akurasi pelatihan model Cat Boost Classifier adalah {cat_train_acc}")
print(f"Akurasi pengujian model Cat Boost Classifier adalah {cat_test_acc}")

Akurasi pelatihan model Cat Boost Classifier adalah 0.8198019801980198 Akurasi pengujian model Cat Boost Classifier adalah 0.7751479289940828

Extreme Gradient Boosting (XGBoost)

from xgboost import XGBClassifier

xgb = XGBClassifier(booster='gblinear', learning_rate=1, max_depth=3, n_estimators=10)
xgb.fit(X_train, y_train)

xgb_train_acc = accuracy_score(y_train, xgb.predict(X_train))
xgb_test_acc = accuracy_score(y_test, y_pred)

print(f'Akurasi pelatihan model XGB adalah {xgb_train_acc}')
print(f'Akurasi pengujian model XGB adalah {xgb_test_acc}')

Akurasi pelatihan model XGB adalah 0.6851485148514852 Akurasi pengujian model XGB adalah 0.7751479289940828

Stacking

Stacking merupakan cara untuk mengkombinasi beberapa model, dengan konsep meta learner. dipakai setelah bagging dan boosting. tidak seperti bagging dan boosting, stacking memungkinkan mengkombinasikan model dari tipe yang berbeda. Ide dasarnya adalah untuk train learner tingkat pertama menggunakan kumpulan data training asli, dan kemudian menghasilkan kumpulan data baru untuk melatih learner tingkat kedua, di mana output dari learner tingkat pertama dianggap sebagai fitur masukan sementara yang asli label masih dianggap sebagai label data training baru. Pembelajar tingkat pertama sering dihasilkan dengan menerapkan algoritma learning yang berbeda.

Dalam fase training pada stacking, satu set data baru perlu dihasilkan dari classifier tingkat pertama. Jika data yang tepat yang digunakan untuk melatih classifier tingkat pertama juga digunakan untuk menghasilkan kumpulan data baru untuk melatih classifier tingkat kedua. proses tersebut memiliki risiko yang tinggi yang akan mengakibatkan overfitting. sehingga disarankan bahwa contoh yang digunakan untuk menghasilkan kumpulan data baru dikeluarkan dari contoh data training untuk learner tingkat pertama, dan prosedur crossvalidasi.

# membagi dataset menjadi set pelatihan dan set pisahan sebesar 50%
from sklearn.model_selection import train_test_split

train, val_train, test, val_test = train_test_split(X, y, test_size=0.5, random_state=355)

# memisahkan lagi set pelatihan menjadi set data pelatihan dan pengujian
X_train, X_test, y_train, y_test = train_test_split(train, test, test_size=0.2, random_state=355)

# menggunakan Regresi Logistik dan algoritma SVM sebagai model dasar.
# Mari menyesuaikan/fit kedua model terlebih dahulu pada data X_train dan y_train.
lr = LogisticRegression()
lr.fit(X_train, y_train)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True, intercept_scaling=1, l1_ratio=None, max_iter=100, multi_class='auto', n_jobs=None, penalty='l2', random_state=None, solver='lbfgs', tol=0.0001, verbose=0, warm_start=False)

svm = SVC()
svm.fit(X_train, y_train)

SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf', max_iter=-1, probability=False, random_state=None, shrinking=True, tol=0.001, verbose=False)

# Mendapatkan prediksi dari semua model dasar pada set validasi val_train.
predict_val1 = lr.predict(val_train)
predict_val2 = svm.predict(val_train)

# Menyusun nilai prediksi untuk set validasi sebagai 'predict_val'
predict_val = np.column_stack((predict_val1, predict_val2))

# Mendapatkan prediksi dari semua model dasar pada set pengujian X_test.
predict_test1 = lr.predict(X_test)
predict_test2 = svm.predict(X_test)

# Meyusun nilai prediksi untuk set validasi sebagai 'predict_test'
predict_test = np.column_stack((predict_test1, predict_test2))

# Menggunakan Stacked data 'predict_val' dan val_test sebagai fitur masukan untuk meta_model, yaitu pengklasifikasi random forest.
rand_clf = RandomForestClassifier()
rand_clf.fit(predict_val, val_test)

RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None, criterion='gini', max_depth=None, max_features='auto', max_leaf_nodes=None, max_samples=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=None, oob_score=False, random_state=None, verbose=0, warm_start=False)

# Memeriksa keakuratan meta_model kita menggunakan predict_test dan y_test.
stacking_acc = accuracy_score(y_test, rand_clf.predict(predict_test))
print(stacking_acc)

0.8235294117647058

confusion_matrix(y_test, rand_clf.predict(predict_test))

array([[43, 5], [ 7, 13]])

print(classification_report(y_test, rand_clf.predict(predict_test)))

precision recall f1-score support 0 0.86 0.90 0.88 48 1 0.72 0.65 0.68 20 accuracy 0.82 68 macro avg 0.79 0.77 0.78 68 weighted avg 0.82 0.82 0.82 68

# Skor akurasi meningkat pesat setelah penggunaan stacking.
models = ['Logistic Regression', 'KNN', 'SVC', 'Decision Tree', 'Random Forest','Ada Boost', 'Gradient Boosting', 'SGB', 'XgBoost', 'Stacking', 'Cat Boost']
scores = [lr_test_acc, knn_test_acc, svc_test_acc, dtc_test_acc, rand_clf_test_acc, ada_test_acc, gb_test_acc, sgbc_test_acc, xgb_test_acc, stacking_acc, cat_test_acc]

models = pd.DataFrame({'Model' : models, 'Score' : scores})


models.sort_values(by = 'Score', ascending = False)

	Model	Score
9	Stacking	0.823529
4	Random Forest	0.781065
5	Ada Boost	0.781065
6	Gradient Boosting	0.781065
7	SGB	0.781065
0	Logistic Regression	0.775148
8	XgBoost	0.775148
10	Cat Boost	0.775148
2	SVC	0.763314
1	KNN	0.751479
3	Decision Tree	0.704142

plt.figure(figsize=(17,7))

sns.barplot(x='Model', y='Score', data=models)
plt.show()

Sunday, May 16, 2021

Prediksi & Klasifikasi Penyakit Diabetes

Regresion Logistic Classifier

K Neighbors Classifier (KNN)

Support Vector Classifier

Decision Tree Classifier

Random Forest Classifier

Boosting

Ada Boost Classifier

Gradient Boosting Classifier

Stochastic Gradient Boosting (SGB)

Cat Boost Classifier

Extreme Gradient Boosting (XGBoost)

Stacking

No comments:

Post a Comment

Buku Gratis

Network Security

Computer Network Management

Blog Archive

Labels

About Me

Popular Posts

Contact Form