Assalamu‘alaikum wr. wb.
Halo gais! Dalam Data Science dikenal sebagai Predictive Modeling Analysis, yaitu untuk Prediksi dan Peluang/Probabilitas untuk Masa Depan. Kali ini, juga akan membandingkan Perbandingan Model Machine Learning seperti Decision Tree, Random Forest, Naive Bayes, dan XGBoost untuk ROC Curve.
PREDICTIVE MODELING
Sumber Materi : Askpython.com, Analyticsvidhya.com (Blog), dan 365datascience.com
A. Pengertian Predictive Modeling
Analisis Model Prediktif (Predictive Modeling Analysis) adalah bagian dari Ilmu Data yang melibatkan pembuatan prediksi tentang peristiwa di masa depan. Kita dapat membuat prediksi tentang data baru untuk kebakaran atau beberapa hari mendatang dan membuat mesin mendukung hal yang sama. Kami menggunakan berbagai teknik statistik untuk menganalisis data atau observasi saat ini dan memprediksi untuk masa depan.
Sebagai contoh, Anda dapat membangun sistem rekomendasi yang menghitung kemungkinan perkembangan penyakit, seperti diabetes, menggunakan beberapa data klinis & pribadi seperti:
- Usia
- Jenis Kelamin
- Berat Badan
- Tingkat glukosa rata-rata
- Kalori Harian
Dengan cara ini, dokter lebih siap untuk melakukan intervensi dengan obat-obatan atau merekomendasikan gaya hidup yang lebih sehat.
Contoh penggunaan lain untuk model prediktif adalah meramalkan penjualan. Dengan menggunakan analisis deret waktu, Anda dapat mengumpulkan dan menganalisis kinerja perusahaan untuk memperkirakan jenis pertumbuhan yang dapat Anda harapkan di masa depan.
Pada dasarnya, dengan pemrograman prediktif, Anda mengumpulkan data historis, menganalisanya, dan melatih model yang mendeteksi pola khusus sehingga ketika menemui data baru nanti, model tersebut dapat memprediksi hasil masa depan.
Ada berbagai model prediktif yang dapat Anda bangun menggunakan algoritma yang berbeda. Pilihan populer termasuk regresi, jaringan saraf, pohon keputusan, pengelompokan K-means, Naïve Bayes, dan lainnya.
B. Penerapan Predictive Modeling
Ada banyak cara untuk menerapkan model prediktif di dunia nyata. Sebagian besar industri menggunakan pemrograman prediktif baik untuk mendeteksi penyebab masalah atau untuk meningkatkan hasil di masa depan. Aplikasi meliputi tetapi tidak terbatas pada :
- Deteksi Penipuan
- Ramalan Penjualan
- Bantuan Bencana Alam
- Pertumbuhan Kinerja Bisnis
- Pengenalan Suara
- Kategorisasi Berita
- Perawatan Kendaraan
Saat industri berkembang, demikian pula aplikasi dari model-model ini. Perusahaan terus mencari cara untuk meningkatkan proses dan membentuk ulang dunia melalui data. Dalam beberapa tahun, Anda dapat mengharapkan menemukan cara-cara yang bahkan lebih beragam untuk mengimplementasikan model Python dalam alur kerja ilmu data Anda.
C. Manfaat dari Analisis Predictive Modeling
Jika dilakukan dengan benar, analisis prediktif dapat memberikan beberapa manfaat. Beberapa fitur kunci yang sangat bertanggung jawab dalam memilih analisis prediktif adalah sebagai berikut.
1. Sistem Umpan Balik Langsung (Immediate Feedback System)
Ini memberikan strategi pemasaran yang lebih baik juga. Dalam hal mengambil layanan pemasaran atau bisnis apa pun, kita bisa mendapatkan gambaran tentang seberapa banyak orang menyukainya, seberapa banyak orang menyukainya, dan yang lebih penting lagi fitur tambahan apa yang mereka benar-benar ingin ditambahkan.
Ini mencari tahu tren saat ini.
2. Optimisasi
Kita dapat mengoptimalkan prediksi kita serta strategi yang akan datang menggunakan analisis prediktif. Optimisasi ini mirip dengan modifikasi, dan melibatkan perbandingan antara strategi saat ini, masa lalu, dan mendatang.
3. Strategi yang Lebih Baik
Kita akan mendapatkan strategi yang lebih baik menggunakan sistem umpan balik langsung dan proses optimisasi ini. Predictive Modeling juga memberikan beberapa strategi, dan mengarah pada keputusan yang lebih baik.
4. Pengurangan Risiko
Ketika kita tidak tahu tentang optimisasi atau tidak sadar akan sistem umpan balik, kita hanya bisa melakukan Pengurangan Risiko juga, sangat cocok untuk para pendatang baru.
D. Langkah-langkah dalam melakukan Analisis Predictive Modeling
Berikut ini adalah beberapa Langkah dalam melakukan Analisis Predictive Modeling :
1. Definisi Masalah
Tujuannya adalah menentukan apa masalah kita. Kita perlu menyelesaikan hal yang sama. Masalah utama yang perlu kita prediksi. Setiap bidang analisis prediktif harus didasarkan pada definisi masalah ini juga.
2. Pengumpulan Data
Kita mengumpulkan data dari berbagai sumber untuk dianalisis dan membuat model peran kita.
3. Pembersihan Data
Kita bisa melihat nilai yang hilang dan yang tidak penting. Mereka perlu dihapus. Kualitas model ini perlu ditingkatkan dengan mengoptimalkannya. Kita perlu menghapus nilai-nilai di luar batas level.
4. Analisis Data
Ini melibatkan pengelolaan data yang terkumpul. Mengelola data merujuk pada memeriksa apakah data itu terorganisir dengan baik atau tidak.
5. Pemodelan
Langkah ini melibatkan menyimpan data yang telah difinalisasi atau terorganisir dengan mesin kita dengan menginstalnya menggunakan algoritma yang sesuai.
6. Penguji Model
Kita perlu menguji mesin apakah bekerja sesuai atau tidak. Kita perlu memeriksa atau membandingkan nilai hasil/keluaran dengan nilai-nilai prediktif.
Menganalisis data yang dibandingkan dalam rentang 0 hingga 1 di mana 0 merujuk pada 0% dan 1 merujuk pada 100%.
7. Pengimplementasian
Setelah model kita dibuat atau berperforma dengan baik atau mendapatkan skor akurasi keberhasilan, maka kita perlu mengimplementasikannya untuk penggunaan di pasar.
CONTOH MODEL DENGAN PYTHON DAN PENJELASANNYA [DECISION TREE VS RANDOM FOREST VS NAIVE BAYES VS XGBOOST]
Sumber : Menggunakan ChatGPT
1. Instalasi Library Pydotplus
Pertama, lakukanlah Instalasi Library Package pydotplus dengan mengetik :
pip install pydotplus
.jpg)
2. Menyiapkan Dataset
Berikut ini adalah Perbandingan Model antara Decision Tree, Random Forest, Naive Bayes, dan XGBoost dengan Python. Dan Pertama, Anda bisa mengunduh (Download) File diabetes.csv di sini.
Kemudian, masukkanlah Kode Program berikut ini untuk memuat Dataset diabetes.csv :
import pandas as pdfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.model_selection import train_test_splitfrom sklearn import metricsfrom scipy.stats import zscore# Load the datasetcol_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']pima = pd.read_csv('diabetes.csv', header=None, names=col_names)# Drop the first rowpima = pima.drop(index=0)# Reset the index after dropping the rowpima = pima.reset_index(drop=True)pima = pima.apply(pd.to_numeric, errors='coerce')pima = pima.fillna(pima.mean())#Outliersz_scores = zscore(pima)abs_z_scores = abs(z_scores)filtered_entries = (abs_z_scores < 3).all(axis=1)pima = pima[filtered_entries]# Define feature columnsfeature_cols = ['pregnant', 'insulin', 'bmi', 'age', 'glucose', 'bp', 'pedigree']X = pima[feature_cols] # Featuresy = pima.label # Target variable# Split the dataset into training and testing setsX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)
Setelah itu, tambahkan pima.head() untuk menampilkan Tabel isi dari Dataset yang telah diberikan.
pima.head()
Output :
pregnant glucose bp skin insulin bmi pedigree age label 0 6 148 72 35 0 33.6 0.627 50 1 1 1 85 66 29 0 26.6 0.351 31 0 2 8 183 64 0 0 23.3 0.672 32 1 3 1 89 66 23 94 28.1 0.167 21 0 5 5 116 74 0 0 25.6 0.201 30 0
Dan, tambahkan pima.info() untuk menampilkan Informasi Tipe Data.
pima.info()
Output :
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 768 entries, 0 to 767
Data columns (total 9 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 pregnant 768 non-null object
1 glucose 768 non-null object
2 bp 768 non-null object
3 skin 768 non-null object
4 insulin 768 non-null object
5 bmi 768 non-null object
6 pedigree 768 non-null object
7 age 768 non-null object
8 label 768 non-null object
dtypes: object(9)Selanjutnya, kita akan menggunakan Model Machine Learning untuk mengolah dan menanalisis Kurva ROC.
A. Decision Tree
Model Klasifikasi atau Regresi yang dibangun dalam bentuk Pohon. Decision Tree menggunakan aturan-aturan keputusan untuk mempartisi data berdasarkan fitur-fitur yang ada.
- Kelebihan : Mudah diinterpretasikan, tidak memerlukan pra-pemrosesan yang kompleks.
- Kekurangan : Rentan terhadap overfitting dan kurang stabil jika data berubah.
Marilah kita akan melanjutkan untuk menggunakan Model Decision Tree sesuai dengan Dataset diabetes.csv di atas.
Pertama, kita masukkan beberapa Kode Program berikut ini seperti Library/Pustaka Python (Seperti export_graphviz, IPython, sampai dengan sklearn.tree). Kemudian, lakukan Persiapan Decision Tree Model dan Export Decision Tree menjadi Format DOT. Setelah itu, membuat Graph dari data DOT menggunakan Library pydotplus. Kemudian, menulis dan mengonversi dari Graf ke File PNG. Setelah itu, melakukan Visualisasi Decision Tree dalam Format Teks.
from sklearn.tree import export_graphviz, export_textfrom IPython.display import Imageimport pydotplusfrom io import StringIO# Assuming `clf` is your decision tree model and `feature_cols` are your feature columns# Make sure you have already trained your decision tree model before running this code# Create a StringIO object to hold the dot datadot_data = StringIO()# Export the decision tree to the StringIO objectexport_graphviz(clf, out_file=dot_data, filled=True, rounded=True, special_characters=True, feature_names=feature_cols, class_names=['0', '1'])# Create a graph from the dot datagraph = pydotplus.graph_from_dot_data(dot_data.getvalue())# Write the graph to a PNG filegraph.write_png('diabetes.png')# Display the PNG imageImage(graph.create_png())# Alternatively, you can visualize the decision tree in text formattree_rules = export_text(clf, feature_names=feature_cols)print(tree_rules)
Output :
|--- glucose <= 154.50 | |--- age <= 28.50 | | |--- bmi <= 47.70 | | | |--- bmi <= 30.90 | | | | |--- pregnant <= 7.00 | | | | | |--- glucose <= 132.00 | | | | | | |--- class: 0 | | | | | |--- glucose > 132.00 | | | | | | |--- insulin <= 41.50 | | | | | | | |--- pregnant <= 1.50 | | | | | | | | |--- class: 0 | | | | | | | |--- pregnant > 1.50 | | | | | | | | |--- class: 1 | | | | | | |--- insulin > 41.50 | | | | | | | |--- class: 0 | | | | |--- pregnant > 7.00 | | | | | |--- class: 1 | | | |--- bmi > 30.90 | | | | |--- bmi <= 31.75 | | | | | |--- age <= 24.50 | | | | | | |--- pedigree <= 1.03 | | | | | | | |--- class: 0 | | | | | | |--- pedigree > 1.03 | | | | | | | |--- class: 1 | | | | | |--- age > 24.50 ... | | | | | |--- class: 1 | | |--- pedigree > 1.41 | | | |--- class: 0
Penjelasan :
Jika tingkat glukosanya lebih tinggi dari 154.50, dan pedigree nya lebih tinggi dari 1.41, diprediksikan tidak memiliki diabetes.
Jika tingkat glukosanya kurang dari 154.50 dan umur nya kurang dari sama dengan 28.5 tahun. Ada beberapa analisis di bawah ini :
- BMI lebih dari 47.7 dan pedigreenya lebih tinggi dari 1.41, maka diprediksikan tidak memiliki diabetes
- BMI antara 30.90 - 31.75, umurnya kurang lebih sama dengan 24.5 dan pedigree kurang dari 1.03 maka diprediksikan tidak memiliki diabetes. Tetapi jika umurnya lebih tua dari 24.5 maka diprediksikan memiliki diabetes
- BMI kurang dari 30.90, dan pernah hamil lebih dari 7 kali, maka diprediksikan memiliki diabetes
- BMI kurang dari 30.90, pernah hamil kurang dari 7 kali, dengan apapun kadar glukosa dan insulinnya, maka diprediksikan tidak memiliki diabetes
Setelah itu, kita tentukan Akurasi, Confusion Matrix, dan Classification Report untuk metode Decision Tree.
# Create Decision Tree classifer objectclf = DecisionTreeClassifier(criterion="entropy", max_depth=3)# Train Decision Tree Classiferclf = clf.fit(X_train,y_train)#Predict the response for test datasety_pred = clf.predict(X_test)print("Accuracy:",metrics.accuracy_score(y_test, y_pred))# Print other metrics if neededprint("Confusion Matrix:")print(metrics.confusion_matrix(y_test, y_pred))print("Classification Report:")print(metrics.classification_report(y_test, y_pred))
Hasil Output :
Accuracy: 0.7584541062801933
Confusion Matrix:
[[134 7]
[ 43 23]]
Classification Report:
precision recall f1-score support
0 0.76 0.95 0.84 141
1 0.77 0.35 0.48 66
accuracy 0.76 207
macro avg 0.76 0.65 0.66 207
weighted avg 0.76 0.76 0.73 207Setelah itu, buatlah Objek pada Decision Tree Classifier menggunakan data X_train dan y_train betikut ini :
# Create Decision Tree classifer objectclf = DecisionTreeClassifier()# Train Decision Tree Classiferclf = clf.fit(X_train,y_train)#Predict the response for test datasety_pred = clf.predict(X_test)print("Accuracy:",metrics.accuracy_score(y_test,y_pred))
Output :
Accuracy: 0.7391304347826086
Berdasarkan Hasil di atas, kita mendapatkan Akurasi sebesar 0.7391 atau sekitar 73,913% dengan menggunakan Decision Tree.
B. Random Forest
Random Forest bersifat Ensemble Learning yang terdiri dari banyak Decision Tree., karena menerapkan teknik ensemble untuk meningkatkan kinerja dan mengurangi overfitting. Setiap Decision Tree dibangun secara independen, dan hasilnya diambil melalui voting atau averaging.
- Kelebihan : Mengatasi kelemahan decision tree dengan meningkatkan keakuratan dan kestabilan.
- Kekurangan : Lebih kompleks, sulit diinterpretasikan dibandingkan dengan decision tree tunggal.
Kali ini, kita akan memasukkan beberapa Kode Program berikut ini untuk Model ML Random Forest. Adapun Library yang dibutuhkan untuk Random Forest adalah Pandas, SciPy, dan Scikit-Learn. Kemudian, masukkan kembali Dataset diabetes.csv, dan melakukan Pemrosesan Data seperti :
- Menghapus baris pertama yang mungkin berisi header yang salah.
- Mereset indeks DataFrame setelah menghapus baris.
- Mengubah kolom ke tipe numerik dan mengganti nilai yang hilang dengan nilai rata-rata.
Setelah itu, lakukanlah Handling Outliers menggunakan skor z untuk mendeteksi dan menghapus outlier dari dataset. Kemudian, lakukanlah Pemilihan Kolom Fitur dan target dari Dataset untuk mendefinisi Fitur Kolom. Terakhir, lakukan Pemisahan Dataset seperti X_train, X_test, y_train, dan y_test.
Berikut ini adalah Program Lengkapnya :
import pandas as pdfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.model_selection import train_test_splitfrom sklearn import metricsfrom scipy.stats import zscore# Load the datasetcol_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']pima = pd.read_csv('diabetes.csv', header=None, names=col_names)# Drop the first rowpima = pima.drop(index=0)# Reset the index after dropping the rowpima = pima.reset_index(drop=True)pima = pima.apply(pd.to_numeric, errors='coerce')pima = pima.fillna(pima.mean())#Outliersz_scores = zscore(pima)abs_z_scores = abs(z_scores)filtered_entries = (abs_z_scores < 3).all(axis=1)pima = pima[filtered_entries]# Define feature columnsfeature_cols = ['pregnant', 'insulin', 'bmi', 'age', 'glucose', 'bp', 'pedigree']X = pima[feature_cols] # Featuresy = pima.label # Target variable# Split the dataset into training and testing setsX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)
Jika sudah, buatlah Fungsi untuk melatih Model dengan Fungsi train_rf_n_times(). Jika sudah, kita akan melatih Model untuk beberapa kali dengan n_estimators=100, max_depth=None, min_samples_split=10, dan min_samples_leaf=1.
def train_rf_n_times(n):total_accuracy = 0.0best_accuracy = 0.0for _ in range(n):# Create a Random Forest modelrf_model = RandomForestClassifier(n_estimators=100, max_depth=None, min_samples_split=10, min_samples_leaf=1)# Train the modelrf_model.fit(X_train, y_train)# Make predictions on the test sety_pred = rf_model.predict(X_test)# Evaluate the modelaccuracy = metrics.accuracy_score(y_test, y_pred)# Update total accuracytotal_accuracy += accuracy# Update best accuracy if the current accuracy is higherbest_accuracy = max(best_accuracy, accuracy)# Calculate average accuracyaverage_accuracy = total_accuracy / nreturn best_accuracy, average_accuracy# Set the number of repetitionsnum_repetitions = 100# Train the model multiple timeshighest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)# Print the highest and average accuracyprint(f"Highest Accuracy over {num_repetitions} repetitions: {highest_accuracy}")print(f"Average Accuracy over {num_repetitions} repetitions: {average_accuracy}")
Untuk mengetahui Rata-rata dan Akurasi Tertinggi sebanyak 100 Repetisi, inilah Hasil Output-nya :
Highest Accuracy over 100 repetitions: 0.8164251207729468 Average Accuracy over 100 repetitions: 0.7927053140096615
Selanjutnya, lakukan hal yang sama seperti di atas dan membuat Fungsi untuk melatih Model dengan Fungsi train_rf_n_times(). Jika sudah, kita akan melatih Model untuk beberapa kali dengan n_estimators=50, max_depth=200, min_samples_split=10, dan min_samples_leaf=1.
def train_rf_n_times(n):total_accuracy = 0.0best_accuracy = 0.0for _ in range(n):# Create a Random Forest modelrf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=10, min_samples_leaf=1)# Train the modelrf_model.fit(X_train, y_train)# Make predictions on the test sety_pred = rf_model.predict(X_test)# Evaluate the modelaccuracy = metrics.accuracy_score(y_test, y_pred)# Update total accuracytotal_accuracy += accuracy# Update best accuracy if the current accuracy is higherbest_accuracy = max(best_accuracy, accuracy)# Calculate average accuracyaverage_accuracy = total_accuracy / nreturn best_accuracy, average_accuracy# Set the number of repetitionsnum_repetitions = 100# Train the model multiple timeshighest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)# Print the highest and average accuracyprint(f"Highest Accuracy over {num_repetitions} repetitions: {highest_accuracy}")print(f"Average Accuracy over {num_repetitions} repetitions: {average_accuracy}")
Untuk mengetahui Rata-rata dan Akurasi Tertinggi sebanyak 100 Repetisi, inilah Hasil Output-nya :
Highest Accuracy over 100 repetitions: 0.8164251207729468 Average Accuracy over 100 repetitions: 0.7959420289855071
Lakukan lagi dengan hal yang sama dengan :
n_estimators=100, max_depth=None, min_samples_split=4, min_samples_leaf=8, criterion='gini', dan n_jobs=-1.
def train_rf_n_times(n):total_accuracy = 0.0best_accuracy = 0.0for _ in range(n):# Create a Random Forest modelrf_model = RandomForestClassifier(n_estimators=100, max_depth=None, min_samples_split=4, min_samples_leaf=8, criterion='gini', n_jobs=-1)# Train the modelrf_model.fit(X_train, y_train)# Make predictions on the test sety_pred = rf_model.predict(X_test)# Evaluate the modelaccuracy = metrics.accuracy_score(y_test, y_pred)# Update total accuracytotal_accuracy += accuracy# Update best accuracy if the current accuracy is higherbest_accuracy = max(best_accuracy, accuracy)# Calculate average accuracyaverage_accuracy = total_accuracy / nreturn best_accuracy, average_accuracy# Set the number of repetitionsnum_repetitions = 100# Train the model multiple timeshighest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)# Print the highest and average accuracyprint(f"Highest Accuracy over {num_repetitions} repetitions: {highest_accuracy}")print(f"Average Accuracy over {num_repetitions} repetitions: {average_accuracy}")
Hasil Output :
Highest Accuracy over 100 repetitions: 0.8067632850241546 Average Accuracy over 100 repetitions: 0.7935748792270533
n_estimators=50, max_depth=200, min_samples_split=15, dan min_samples_leaf=4.
def train_rf_n_times(n):total_accuracy = 0.0best_accuracy = 0.0for _ in range(n):# Create a Random Forest modelrf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=15, min_samples_leaf=4)# Train the modelrf_model.fit(X_train, y_train)# Make predictions on the test sety_pred = rf_model.predict(X_test)# Evaluate the modelaccuracy = metrics.accuracy_score(y_test, y_pred)# Update total accuracytotal_accuracy += accuracy# Update best accuracy if the current accuracy is higherbest_accuracy = max(best_accuracy, accuracy)# Calculate average accuracyaverage_accuracy = total_accuracy / nreturn best_accuracy, average_accuracy# Set the number of repetitionsnum_repetitions = 100# Train the model multiple timeshighest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)# Print the highest and average accuracyprint(f"Highest Accuracy over {num_repetitions} repetitions: {highest_accuracy}")print(f"Average Accuracy over {num_repetitions} repetitions: {average_accuracy}")
Hasil Output :
Highest Accuracy over 100 repetitions: 0.821256038647343 Average Accuracy over 100 repetitions: 0.795217391304348
n_estimators=50, max_depth=200, min_samples_split=15, min_samples_leaf=3, criterion='entropy', dan max_features='log2'.
def train_rf_n_times(n):total_accuracy = 0.0best_accuracy = 0.0for _ in range(n):# Create a Random Forest modelrf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=15, min_samples_leaf=3, criterion='entropy', max_features='log2')# Train the modelrf_model.fit(X_train, y_train)# Make predictions on the test sety_pred = rf_model.predict(X_test)# Evaluate the modelaccuracy = metrics.accuracy_score(y_test, y_pred)# Update total accuracytotal_accuracy += accuracy# Update best accuracy if the current accuracy is higherbest_accuracy = max(best_accuracy, accuracy)# Calculate average accuracyaverage_accuracy = total_accuracy / nreturn best_accuracy, average_accuracy# Set the number of repetitionsnum_repetitions = 300# Train the model multiple timeshighest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)# Print the highest and average accuracyprint(f"Highest Accuracy over {num_repetitions} repetitions: {highest_accuracy}")print(f"Average Accuracy over {num_repetitions} repetitions: {average_accuracy}")
Hasil Output :
Highest Accuracy over 300 repetitions: 0.8260869565217391 Average Accuracy over 300 repetitions: 0.796988727858294
Setelah itu, kita tentukan Akurasi, Confusion Matrix, dan Classification Report untuk metode Random Forest.
# Create a Random Forest modelrf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=15, min_samples_leaf=3, criterion='entropy', max_features='log2')# Train the modelrf_model.fit(X_train, y_train)# Make predictions on the test sety_pred = rf_model.predict(X_test)# Evaluate the modelaccuracy = metrics.accuracy_score(y_test, y_pred)print(f"Accuracy: {accuracy}")# Print other metrics if neededprint("Confusion Matrix:")print(metrics.confusion_matrix(y_test, y_pred))print("Classification Report:")print(metrics.classification_report(y_test, y_pred))
Hasil Output :
Accuracy: 0.8260869565217391
Confusion Matrix:
[[131 10]
[ 26 40]]
Classification Report:
precision recall f1-score support
0 0.83 0.93 0.88 141
1 0.80 0.61 0.69 66
accuracy 0.83 207
macro avg 0.82 0.77 0.78 207
weighted avg 0.82 0.83 0.82 207C. Gaussian Naïve-Bayes
Gaussian Naive Bayes berdasarkan Teorema Bayessian. Proses Pembelajaran yang menggunakan asumsi bahwa setiap fitur adalah independen dari yang lain, dan memanfaatkan distribusi Gaussian. Tidak termasuk dalam ensemble method; model yang relatif sederhana.
- Kelebihan : Cepat, efisien, dan efektif pada data dengan asumsi independensi fitur.
- Kekurangan : Asumsi bahwa fitur-fitur independen mungkin tidak sesuai dengan semua jenis data.
Untuk metode Gaussian Naive Bayes, masukkan terlebih dahulu beberapa Library Python seperti NumPy dan Scikit-Learn. Kemudian, Visualisasi kembali Dataset diabetes.csv dengan variabel databayes.
# Import Gaussian Naive Bayes modelimport numpy as npfrom sklearn.naive_bayes import GaussianNBfrom sklearn.model_selection import GridSearchCVfrom sklearn import preprocessingdatabayes = pd.read_csv("diabetes.csv")databayes.head()databayes = databayes.fillna(databayes.mean())
Hasil Output :
Setelah itu, kita tentukan Akurasi, Confusion Matrix, dan Classification Report untuk metode Gaussian Naive Bayes. Berikut ini adalah beberapa Penjelasan pada Kode Program berikut ini :
Create a Gaussian Classifier :
- Pada baris pertama, model Gaussian Naive Bayes dibuat dengan menggunakan objek GaussianNB() dari modul sklearn.naive_bayes.
Train the Model :
- Baris kedua dan ketiga digunakan untuk melatih model dengan menggunakan data training (X_train dan y_train).
- X_train adalah features dari data training.
- y_train adalah label atau target variable dari data training.
- model.fit(X_train, y_train.values.ravel()) digunakan untuk melakukan proses training pada model.
Make Predictions :
- Baris keempat melakukan prediksi menggunakan data testing (X_test).
- y_pred = model.predict(X_test) menghasilkan prediksi label dari data testing.
Print Accuracy, Confusion Matrix, and Classification Report :
- Baris keenam mencetak akurasi model menggunakan fungsi metrics.accuracy_score.
- Baris kedelapan mencetak confusion matrix menggunakan fungsi metrics.confusion_matrix.
- Baris kesepuluh mencetak classification report menggunakan fungsi metrics.classification_report.
#Create a Gaussian Classifiermodel = GaussianNB()# Train the model using the training setsmodel.fit(X_train,y_train.values.ravel())# Train the model using the testing setsy_pred= model.predict(X_test)print("Accuracy:", metrics.accuracy_score(y_test,y_pred))print("Confusion Matrix:")print(metrics.confusion_matrix(y_test, y_pred))print("Classification Report:")print(metrics.classification_report(y_test, y_pred))
Hasil Output :
Accuracy: 0.8019323671497585
Confusion Matrix:
[[122 19]
[ 22 44]]
Classification Report:
precision recall f1-score support
0 0.85 0.87 0.86 141
1 0.70 0.67 0.68 66
accuracy 0.80 207
macro avg 0.77 0.77 0.77 207
weighted avg 0.80 0.80 0.80 207Untuk selengkapnya tentang Naïve-Bayes, silakan lihat di sini.
D. XGBoost
Extreme Gradient Boosting (XGBoost) termasuk dalam kategori Boosting Ensemble, karena menggunakan banyak decision tree yang dibangun secara berurutan untuk memperbaiki kesalahan model sebelumnya. Proses Pembelajaran yang digunakan adalah dengan menggabungkan kelemahan dari model-model yang lemah untuk membentuk model yang kuat.
- Kelebihan : Kinerja tinggi, tahan terhadap overfitting, dapat menangani berbagai jenis data.
- Kekurangan : Kompleks, memerlukan penyetelan parameter dengan hati-hati.
Untuk melakukan XGBoost, lakukan Instalasi Library terlebih dahulu. Kemudian, masukkan juga Dataset dari diabetes.csv bseserta dengan Nama Kolom. Setelah itu, lakukan juga Dropping dan Reset pada Barisan Indeks. Dan, definisikan kembali
import xgboost as xgb# Load the datasetcol_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']pima = pd.read_csv('diabetes.csv', header=None, names=col_names)# Drop the first rowpima = pima.drop(index=0)# Reset the index after dropping the rowpima = pima.reset_index(drop=True)pima = pima.apply(pd.to_numeric, errors='coerce')pima = pima.fillna(pima.mean())# Define feature columnsfeature_cols = ['pregnant', 'insulin', 'bmi', 'age', 'glucose', 'bp', 'pedigree']X = pima[feature_cols] # Featuresy = pima.label # Target variable
Kemudian, pisahan lagi Dataset menjadi Data Testing dan Data Training.
# Split the dataset into training and testing setsX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)
Jika sudah, buatlah Model XGBoost dan lakukan Training, Evaluasi, Prediksi, hingga mencetak (Print) Metriks.
# Create an XGBoost modelxgb_model = xgb.XGBClassifier(objective="binary:logistic",max_depth=None,learning_rate=0.1,n_estimators=20,subsample=1,colsample_bytree=1,gamma=0,min_child_weight=1,reg_alpha=0,reg_lambda=1,random_state=1,eta = 0.1,eval_metric = 'rmse',verbose = 2)# Train the modelxgb_model.fit(X_train, y_train)# Make predictions on the test sety_pred = xgb_model.predict(X_test)# Evaluate the modelaccuracy = metrics.accuracy_score(y_test, y_pred)print(f"Accuracy: {accuracy}")# Print other metrics if neededprint("Confusion Matrix:")print(metrics.confusion_matrix(y_test, y_pred))print("Classification Report:")print(metrics.classification_report(y_test, y_pred))
Hasil Output :
Accuracy: 0.8181818181818182
Confusion Matrix:
[[134 12]
[ 30 55]]
Classification Report:
precision recall f1-score support
0 0.82 0.92 0.86 146
1 0.82 0.65 0.72 85
accuracy 0.82 231
macro avg 0.82 0.78 0.79 231
weighted avg 0.82 0.82 0.81 231E. Analisis Kurva ROC
Sumber : Towardsdatascience.com (Medium.com) dan Analyticsvidhya.com (Blog)
Kurva AUC - ROC adalah pengukuran kinerja untuk masalah klasifikasi pada berbagai pengaturan ambang. ROC adalah kurva probabilitas dan AUC mewakili derajat atau ukuran pemisahan. Ini memberi tahu seberapa mampu model untuk membedakan antara kelas. Semakin tinggi AUC, semakin baik model tersebut dalam memprediksi kelas 0 sebagai 0 dan kelas 1 sebagai 1. Secara analogi, semakin tinggi AUC, semakin baik model tersebut dalam membedakan antara pasien dengan penyakit dan tanpa penyakit.
Kurva ROC digambarkan dengan TPR terhadap FPR di mana TPR berada pada sumbu y dan FPR berada pada sumbu x.
1. Jenis-jenis Perhitungan dalam Kurva ROC
Dari matriks kebingungan, kita dapat memperoleh beberapa metrik penting yang tidak dibahas dalam artikel sebelumnya. Mari kita bahas di sini.
a. Sensitivitas / Recall / Tingkat Positif Benar (True Positive Rate / TPR)
Sensitivitas memberi tahu kita seberapa besar proporsi kelas positif yang terklasifikasi dengan benar.
Contoh sederhana adalah menentukan seberapa besar proporsi orang yang benar-benar sakit yang terdeteksi dengan benar oleh model.
b. Tingkat Kesalahan Negatif (False Negative Rate / FNR)
Tingkat Kesalahan Negatif (FNR) memberi tahu kita seberapa besar proporsi kelas positif yang terklasifikasi secara salah oleh pengklasifikasi.
Sebuah TPR yang lebih tinggi dan FNR yang lebih rendah diinginkan karena kita ingin mengklasifikasikan kelas positif dengan benar.
c. Spesifisitas / Tingkat Negatif Benar (True Negative Rate / TNR)
Spesifisitas memberi tahu kita seberapa besar proporsi kelas negatif yang terklasifikasi dengan benar.
Mengambil contoh yang sama seperti Sensitivitas, Spesifisitas akan berarti menentukan proporsi orang sehat yang teridentifikasi dengan benar oleh model.
d. Tingkat Kesalahan Positif (False Positive Rate / FPR)
FPR memberi tahu kita seberapa besar proporsi kelas negatif yang terklasifikasi secara salah oleh pengklasifikasi.
Sebuah TNR yang lebih tinggi dan FPR yang lebih rendah diinginkan karena kita ingin mengklasifikasikan kelas negatif dengan benar.
Dari metrik-metrik ini, Sensitivitas dan Spesifisitas mungkin yang paling penting, dan kita akan melihat nanti bagaimana ini digunakan untuk membangun metrik evaluasi. Tapi sebelum itu, mari kita pahami mengapa probabilitas prediksi lebih baik daripada langsung memprediksi kelas target.
Keterangan :
- TP = True Positive
- TN = True Negative
- FP = False Positive
- FN = False Negative
2. Analisis Perbandingan Kurva ROC dengan menggunakan Python
Dari Keempat Model Machine Learning yang kita dapatkan di atas bahwa, metode XGBoost lebih baik (81,82%) daripada Random Forest (82,61%), Naive Bayes (80,19%), dan Decision Tree (75,84%) karena meskipun Random Forest memiliki highest accuracy yang lebih tinggi, tetapi Average Accuracynya lebih rendah dan hasil Highest Accuracynya tidak konsisten.
def plot_roc_curve(model, X_test, y_test, label):y_score = model.predict_proba(X_test)[:, 1]fpr, tpr, _ = roc_curve(y_test, y_score)roc_auc = auc(fpr, tpr)plt.plot(fpr, tpr, lw=2, label=f'{label} (AUC = {roc_auc:.2f})')# Create modelsclf = DecisionTreeClassifier(criterion="entropy", max_depth=3)rf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=15, min_samples_leaf=3, criterion='entropy', max_features='log2')xgb_model = xgb.XGBClassifier(objective="binary:logistic",max_depth=None,learning_rate=0.1,n_estimators=20,subsample=1,colsample_bytree=1,gamma=0,min_child_weight=1,reg_alpha=0,reg_lambda=1,random_state=1,eta=0.1,eval_metric='rmse',verbose=2)nb_model = GaussianNB()# Train modelsclf.fit(X_train, y_train)rf_model.fit(X_train, y_train)xgb_model.fit(X_train, y_train)nb_model.fit(X_train, y_train.values.ravel())# Plot ROC curvesplt.figure(figsize=(8, 8))plot_roc_curve(clf, X_test, y_test, 'Decision Tree')plot_roc_curve(rf_model, X_test, y_test, 'Random Forest')plot_roc_curve(xgb_model, X_test, y_test, 'XGBoost')plot_roc_curve(nb_model, X_test, y_test, 'Naive Bayes')plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')plt.xlim([0.0, 1.0])plt.ylim([0.0, 1.05])plt.xlabel('False Positive Rate')plt.ylabel('True Positive Rate')plt.title('Receiver Operating Characteristic (ROC) Curves')plt.legend(loc='lower right')plt.show()
Hasil Output :
Berdasarkan hasil ROC Curves di atas, model ini sudah baik karena garis-garis ROC Curves di atas random classifier (titik-titik). ROC Curve Random Forest, XGBoost, dan Naive Bayes dinilai memiliki kualitas yang sangat baik (di antara 0.8 - 0.9), sedangkan ROC Curve Decision Tree dinilai memiliki kualitas yang baik (di antara 0.7 - 0.8). Dari 4 ROC Curves, yang tertinggi adalah Naive Bayes (0.86)
Sumber Referensi (AUC Value) :
- Trifonova, O. P., Lokhov, P. G., & Archakov, A. I. (2013). Metabolic profiling of human blood. Biochemistry (Moscow) Supplement Series B: Biomedical Chemistry, 7(3), 179–186.
Itulah Predictive Modeling Analysis dalam Data Science, dan beserta dengan Perbandingan Model antara Decision Tree, Random Forest, Naive Bayes, dan XGBoost dengan Python. Mohon maaf apabila ada kesalahan apapun.
Terima Kasih 😄😘👌👍 :)
Wassalamu‘alaikum wr. wb.