Apa itu Predictive Modeling Analysis dalam Data Science? Dan beserta dengan Perbandingan Modelnya dengan ROC Curves [Decision Tree vs Random Forest vs Naïve-Bayes vs XGBoost] dalam Python

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

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 pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn import metrics
from scipy.stats import zscore

# Load the dataset
col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv('diabetes.csv', header=None, names=col_names)

# Drop the first row
pima = pima.drop(index=0)

# Reset the index after dropping the row
pima = pima.reset_index(drop=True)

pima = pima.apply(pd.to_numeric, errors='coerce')

pima = pima.fillna(pima.mean())

#Outliers
z_scores = zscore(pima)
abs_z_scores = abs(z_scores)
filtered_entries = (abs_z_scores < 3).all(axis=1)
pima = pima[filtered_entries]

# Define feature columns
feature_cols = ['pregnant', 'insulin', 'bmi', 'age', 'glucose', 'bp', 'pedigree']
X = pima[feature_cols]  # Features
y = pima.label  # Target variable

# Split the dataset into training and testing sets
X_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_text
from IPython.display import Image
import pydotplus
from 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 data
dot_data = StringIO()

# Export the decision tree to the StringIO object
export_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 data
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())

# Write the graph to a PNG file
graph.write_png('diabetes.png')

# Display the PNG image
Image(graph.create_png())

# Alternatively, you can visualize the decision tree in text format
tree_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 object
clf = DecisionTreeClassifier(criterion="entropy", max_depth=3)
# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)
#Predict the response for test dataset
y_pred = clf.predict(X_test)

print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
# Print other metrics if needed
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.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       207

Setelah itu, buatlah Objek pada Decision Tree Classifier menggunakan data X_train dan y_train betikut ini :

# Create Decision Tree classifer object
clf = DecisionTreeClassifier()
# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)
#Predict the response for test dataset
y_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 pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn import metrics
from scipy.stats import zscore

# Load the dataset
col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv('diabetes.csv', header=None, names=col_names)

# Drop the first row
pima = pima.drop(index=0)

# Reset the index after dropping the row
pima = pima.reset_index(drop=True)

pima = pima.apply(pd.to_numeric, errors='coerce')

pima = pima.fillna(pima.mean())

#Outliers
z_scores = zscore(pima)
abs_z_scores = abs(z_scores)
filtered_entries = (abs_z_scores < 3).all(axis=1)
pima = pima[filtered_entries]

# Define feature columns
feature_cols = ['pregnant', 'insulin', 'bmi', 'age', 'glucose', 'bp', 'pedigree']
X = pima[feature_cols]  # Features
y = pima.label  # Target variable

# Split the dataset into training and testing sets
X_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.0
    best_accuracy = 0.0

    for _ in range(n):
        # Create a Random Forest model
        rf_model = RandomForestClassifier(n_estimators=100, max_depth=None, min_samples_split=10, min_samples_leaf=1)

        # Train the model
        rf_model.fit(X_train, y_train)

        # Make predictions on the test set
        y_pred = rf_model.predict(X_test)

        # Evaluate the model
        accuracy = metrics.accuracy_score(y_test, y_pred)

        # Update total accuracy
        total_accuracy += accuracy

        # Update best accuracy if the current accuracy is higher
        best_accuracy = max(best_accuracy, accuracy)

    # Calculate average accuracy
    average_accuracy = total_accuracy / n

    return best_accuracy, average_accuracy

# Set the number of repetitions
num_repetitions = 100

# Train the model multiple times
highest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)

# Print the highest and average accuracy
print(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.0
    best_accuracy = 0.0

    for _ in range(n):
        # Create a Random Forest model
        rf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=10, min_samples_leaf=1)

        # Train the model
        rf_model.fit(X_train, y_train)

        # Make predictions on the test set
        y_pred = rf_model.predict(X_test)

        # Evaluate the model
        accuracy = metrics.accuracy_score(y_test, y_pred)

        # Update total accuracy
        total_accuracy += accuracy

        # Update best accuracy if the current accuracy is higher
        best_accuracy = max(best_accuracy, accuracy)

    # Calculate average accuracy
    average_accuracy = total_accuracy / n

    return best_accuracy, average_accuracy

# Set the number of repetitions
num_repetitions = 100

# Train the model multiple times
highest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)

# Print the highest and average accuracy
print(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.0
    best_accuracy = 0.0

    for _ in range(n):
        # Create a Random Forest model
        rf_model = RandomForestClassifier(n_estimators=100, max_depth=None, min_samples_split=4, min_samples_leaf=8, criterion='gini', n_jobs=-1)

        # Train the model
        rf_model.fit(X_train, y_train)

        # Make predictions on the test set
        y_pred = rf_model.predict(X_test)

        # Evaluate the model
        accuracy = metrics.accuracy_score(y_test, y_pred)

        # Update total accuracy
        total_accuracy += accuracy

        # Update best accuracy if the current accuracy is higher
        best_accuracy = max(best_accuracy, accuracy)

    # Calculate average accuracy
    average_accuracy = total_accuracy / n

    return best_accuracy, average_accuracy

# Set the number of repetitions
num_repetitions = 100

# Train the model multiple times
highest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)

# Print the highest and average accuracy
print(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.0
    best_accuracy = 0.0

    for _ in range(n):
        # Create a Random Forest model
        rf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=15, min_samples_leaf=4)

        # Train the model
        rf_model.fit(X_train, y_train)

        # Make predictions on the test set
        y_pred = rf_model.predict(X_test)

        # Evaluate the model
        accuracy = metrics.accuracy_score(y_test, y_pred)

        # Update total accuracy
        total_accuracy += accuracy

        # Update best accuracy if the current accuracy is higher
        best_accuracy = max(best_accuracy, accuracy)

    # Calculate average accuracy
    average_accuracy = total_accuracy / n

    return best_accuracy, average_accuracy

# Set the number of repetitions
num_repetitions = 100

# Train the model multiple times
highest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)

# Print the highest and average accuracy
print(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.0
    best_accuracy = 0.0

    for _ in range(n):
        # Create a Random Forest model
        rf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=15, min_samples_leaf=3, criterion='entropy', max_features='log2')

        # Train the model
        rf_model.fit(X_train, y_train)

        # Make predictions on the test set
        y_pred = rf_model.predict(X_test)

        # Evaluate the model
        accuracy = metrics.accuracy_score(y_test, y_pred)

        # Update total accuracy
        total_accuracy += accuracy

        # Update best accuracy if the current accuracy is higher
        best_accuracy = max(best_accuracy, accuracy)

    # Calculate average accuracy
    average_accuracy = total_accuracy / n

    return best_accuracy, average_accuracy

# Set the number of repetitions
num_repetitions = 300

# Train the model multiple times
highest_accuracy, average_accuracy = train_rf_n_times(num_repetitions)

# Print the highest and average accuracy
print(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 model
rf_model = RandomForestClassifier(n_estimators=50, max_depth=200, min_samples_split=15, min_samples_leaf=3, criterion='entropy', max_features='log2')

# Train the model
rf_model.fit(X_train, y_train)

# Make predictions on the test set
y_pred = rf_model.predict(X_test)

# Evaluate the model
accuracy = metrics.accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")

# Print other metrics if needed
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.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       207

C. 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 model
import numpy as np
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import GridSearchCV
from sklearn import preprocessing

databayes = 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 Classifier
model = GaussianNB()
# Train the model using the training sets
model.fit(X_train,y_train.values.ravel())
# Train the model using the testing sets
y_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       207

Untuk 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 dataset
col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv('diabetes.csv', header=None, names=col_names)

# Drop the first row
pima = pima.drop(index=0)

# Reset the index after dropping the row
pima = pima.reset_index(drop=True)

pima = pima.apply(pd.to_numeric, errors='coerce')

pima = pima.fillna(pima.mean())

# Define feature columns
feature_cols = ['pregnant', 'insulin', 'bmi', 'age', 'glucose', 'bp', 'pedigree']
X = pima[feature_cols]  # Features
y = pima.label  # Target variable

Kemudian, pisahan lagi Dataset menjadi Data Testing dan Data Training.

# Split the dataset into training and testing sets
X_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 model
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
)

# Train the model
xgb_model.fit(X_train, y_train)

# Make predictions on the test set
y_pred = xgb_model.predict(X_test)

# Evaluate the model
accuracy = metrics.accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")

# Print other metrics if needed
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.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       231

E. 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 models
clf = 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 models
clf.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 curves
plt.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.