Algoritma Naive Bayes: Pemahaman, Contoh Perhitungan Manual serta Implementasi dengan Python dan Orange Data Mining

1. Apa itu Naive Bayes

Naïve bayes atau dikenal juga dengan naïve bayes classifier merupakan salah satu algoritme machine learning yang diawasi (supervised learning) yang digunakan untuk menangani masalah klasifikasi berdarkan pada probabilitas atau kemungkinan sesuai dengan Teorema Bayes. Lalu, apa itu Teorema Bayes? Dalam statistic, Teorema Bayes atau hukum bayes menjelaskan probabilitas suatu kejadian di masa depan berdasarkan pengalaman sebelumnya tentang kondisi yang mungkin terkait dengan kejadian tersebut, sehingga dapat digunakan untuk pengambilan keputusan. Contoh, terdapat 10 kartu bernomor 1 sampai 10. Jika satu kartu diambil secara acak, maka peluang mendapatkan kartu bernomor 6 adalah 1/10. Angka 1 didapatkan dari kemungkinan kartu bernomor 6 diambil, sedangkan angka 10 merupakan total keseluruhan dari kartu yang ada.

Algoritme Naïve bayes disebut “naif” karena membuat asumsi yang sangat kuat (naif) bahwa kemunculan fitur tertentu tidak tergantung pada kemunculan fitur lainnya (kelas). Misal, pemohon pinjaman (kredit) disetujui atau tidak, tergantung pada pendapatan per bulan, riwayat pinjaman dan transaksi sebelumnya, usia serta lokasi. Meski fitur-fitur tersebut saling bergantung satu sama lain, namun semua fitur-fitur tersebut secara individual memiliki kontribusi pada kemungkinan apakah permohonan kredit seseorang disetujui atau tidak.

Seperti yang telah disebutkan di atas, algoritme naïve bayes merupakan metode yang digunakan dalam machine learning untuk menangani masalah klasifikasi berdasarkan pada probabilitas. Beberapa contoh implementasi algoritme naïve bayes yaitu klasifikasi dokumen, perkiraan cuaca, mendeteksi atau menyaring spam, system rekomendasi, analisis sentiment, dan lain sebagainya. Berdasarkan fungsinya, metode naïve bayes digolongkan menjadi beberapa tipe seperti berikut:

1. Multinomial naïve bayes. Merupakan metode naïve bayes yang digunakan untuk mengklasifikasikan kategori dokumen. Misalnya, sebuah dokumen diklasifikasikan bertema teknologi, olahraga, politik dan lain sebagainya berdasarkan frekuensi kata-kata yang muncul di dalam dokumen tersebut.
2. Gaussian naïve bayes. Adalah tipe naïve bayes yang mendukung data kontinu (tidak terbatas) berdasarkan asumsi ditribusi gaussian.
3. Bernoulli naïve bayes. Metode ini hampir sama seperti tipe multinomial, bedanya, tipe Bernoulli lebih berfokus pada hasil yang bernilai Boolean yaitu benar atau salah. Contoh, prediksi apakah sebuah kata tertentu muncul dalam dokumen teks atau tidak.

2. Alur Kerja Naive Bayes

Setelah kita memahami penjelasan tentang apa itu naïve bayes, selanjutnya, kita akan menyelami lebih dalam terkait cara kerja dari algoritme tersebut. Sebelum melanjutkan, sejenak kita review jika algroitme NBC bekerja berdasarkan pada kemungkinan sesuai dengan Teorema Bayes. Secara matematis, Teorema Bayes dinyatakan dalam rumus berikut:

Picture by author

Sebentar, sebelum kita mengimplementasikan rumus di atas ke dalam studi kasus, kita perlu mengingat kembali bahwa algoritme naïve bayes membuat asumsi yang sangat kuat jika setiap fitur bersifat independent. Artinya, kita bisa menghitung peluang berdasarkan kategori pada atribut terhadap kelasnya. Rumus yang digunakan adalah:

Sampai di sini, apakah penjelasan di atas mudah dipahami? Atau malah bikin perut mual dan mengakibatkan gangguan perasaan? Jangan khawatir. Kita akan melanjutkan penjelasan tentang cara kerja algoritme ini dengan konsep yang lebih sederhana seperti berikut:

a. Pertama, hitung jumlah kelas atau label dari dataset yang digunakan.

b. Kedua, hitung jumlah kasus per kelas.

c. Selanjutnya, kalikan semua hasil sesuai dengan data X yang dicari class-nya.

d. Terakhir, bandingkan hasil probabilitas per kelas. Kelas dengan probabilitas tertinggi merupakan prediksi yang dihasilkan oleh model.

Untuk mempermudah pemahaman, kita akan mengimplementasikan rumus-rumus di atas ke dalam studi kasus. Dataset yang akan digunakan yaitu kumpulan kondisi cuaca dengan variabel target “Play” atau bermain. Dengan dataset tersebut, kita dapat membuat sebuah prediksi apakah seseorang akan bermain golf atau tidak berdasrkan keadaan cuaca pada hari tertentu. Berikut ini dataset yang akan kita gunakan:

Berdasrkan tabel di atas, terlihat dataset tersebut memiliki dua class (target) dengan record (baris) sebanyak 14:

1. Class 1 = Play (Yes) sebanyak 9 record
2. Class 2 = Play (No) sebanyak 5 record

Untuk mempermudah kita dalam memahami informasi, kita akan membuat tabel frekuensi menggunakan setiap aribut dari dataset. Tujuannya, agar kita mengetahui berapa sih orang yang memilih bermain golf ketika cuaca cerah, mendung, dan hujan? Atau berapa sih orang yang memilih tidak bermain golf ketika angin kencang dan lemah? Tabel frekuensi yang terbentuk seperti berikut:

Setelah tabel frekuensi setiap atribut kita buat, selanjutnya kita akan menghitung probabilitas setiap kelas beserta atributnya. Di bawah ini merupakan contoh perhitungan probabilitas setiap kelas dan atribut:

Table di atas merupakan hasil perhitungan probabilitas seluruh fitur yang terdapat pada dataset yang kita miliki. Selanjutnya, kita akan melakukan pengujian dengan sebuah data baru seperti beriku:

Berdasarkan kondisi di atas, untuk mengetahui apakah seseorang akan bermain golf atau tidak pada hari tersebut, maka kita akan menggunakan rumus berikut ini:

Berdasarkan perhitungan di atas, terlihat bahwa probabilitas play (No) lebih besar dari play (Yes). Sehingga, untuk kondisi hari tersebut (Outlook = Rain, Humidity = High, dan Wind = Weak) diklasifikasikan ke dalam hari tidak bermain golf.

Sampai di sini, perhitungan naïve bayes telah selesai. Perhitungan manual digunakan sebagai gambaran untuk kita bagaimana algoritme tersebut bekerja di balik baris kode yang kita gunakan.

3. Contoh Kasus

Pada bagian sebelumnya, kita sudah melakukan perhitungan secara manual untuk mengetahui cara kerja dari algoritme naïve bayes. Mungkin kamu akan bertanya, bagaimana jika data yang kita miliki itu jumlahnya sangat banyak. Apakah kita akan tetap melakukan perhitungan secara manual seperti sebelumnya? Jawabannya tidak. Untuk data dalam jumlah banyak, kita bisa memanfaatkan berbagai tools yang sudah ada, di antaranya yang akan digunakan pada buku ini yaitu Python dan Software Orange data mining. Dataset yang akan kita gunakan pada kasus ini merupakan dataset “diabetes_nb.csv” yang terdiri dari 3 features dan 955 records:

a. Glucose: merupakan fitur yang berisi kadar gula darah pasien.

b. Bloodpressure: fitur yang berisi tekanan darah pasien.

c. Diabetes: yaitu fitur yang akan dijadikan sebagai variabel target. Fitur ini memiliki nilai kategorik 1 dan 0. Nilai 1 memiliki arti pasien positif diabetes dan 0 merupakan pasien yang negative diabetes.

3.1. Kode Python

Pertama, kita akan mengimplementasikan contoh kasus di atas menggunakan bahasa pemrograman Python. Diasumsikan google colab dengan lembar kerja baru sudah dibuka. Selanjutnya, tulis kode di bawah ini dan jalankan:

import pandas as pd
import numpy as np
from numpy import mean
from numpy import std 
from sklearn.preprocessing import MinMaxScaler
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import train_test_split
from sklearn.metrics

Keterangan kode:

• import pandas as pd, mengimport library pandas dengan singkatan pd yang berfungsi untuk mengubah dimensi data, membuat tabel, memeriksa data, membaca data dan lain sebagainya.
• import numpy as np, memanggil library numpy dengan singkatan np untuk memudahkan operasi perhitungan tipe data numerik seperti penjumlahan, perkalian, pengurangan, pemangkatan dan operasi artimatika lainnya.
• from numpy import mean, mengimport fungsi mean dari library numpy untuk mengitung rata-rata.
• from numpy import std, memanggil fungsi std dari library numpy untuk menghitung standar deviasi.
• from sklearn.preprocessing import MinMaxScaler, memanggil fungsi preprocessing untuk melakukan normalisasi data menggunakan MinMaxScaler.
• from sklearn.naive_bayes import GaussianNB, untuk memanggil algoritme naive bayes tipe GasussianNB yang akan digunakan untuk membuat model klasifikasi.
• from sklearn.model_selection import cross_val_score, mengimport fungsi cross_val_score dari library sklearn untuk menghitung hasil akurasi model.
• from sklearn.model_selection import train_test_split, memanggil fungsi train_test_split yang terdapat pada library sklearn untuk membagi dataset ke dalam data training dan data testing.
• from sklearn.metrics import confusion_matrix, mengimport fungsi confusion_matrix untuk mengevaluasi model.

df=pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ diabetes_nb.csv')
​
df

Keterangan kode:

• df=pd.read_csv(‘/content/drive/MyDrive/Colab Notebooks/ diabetes_nb.csv’), perintah yang digunakan untuk membaca dataset yang tersimpan di dalam Google Drive kita dalam format csv.
• df, perintah untuk menampilkan seluruh isi dataset yang kita gunakan. Hasilnya seperti di bawah ini:

Keterangan kode:

• X = df.drop(‘diabetes’, axis=1), menghapus atribut ‘diabetes’dan menentukan atribut lainnya sebagai variabel independent (tidak terpengaruhi).
• y = df[‘diabetes’], menentukan atribut ‘diabetes’sebagai variabel target (label).
• X.shape, y.shape, adalah properti dari objek numpy array yang mengindikasikan bentuk dari array tersebut. X.shape akan mengembalikan tuple berisi dua angka yang menunjukkan jumlah baris dan kolom dalam X. y.shape akan mengembalikan tuple berisi satu angka yang menunjukkan jumlah baris dalam y. Hasilnya adalah ((995, 2), (995,)).

scaler = MinMaxScaler()
​
X = pd.DataFrame(scaler.fit_transform(X), columns=X.columns.values)
​
X

Keterangan kode:

• scaler = MinMaxScaler(), scaler merupakan variabel yang kita buat untuk memanggil fungsi MinMaxScaler yang terdapat pada library sklearn.
• X = pd.DataFrame(scaler.fit_transform(X), columns=X.columns.values), menyimpan dataset yang sudah dinormalisasi ke dalam variabel X.
• X, untuk menampilkan seluruh isi dataset yang sudah dinormalisasikan. Hasilnya seperti di bawah ini:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)

Keterangan kode:

• X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1), menentukan hyperparameter untuk data training dan data testing. Data testing diatur sebanyak 0.20 atau 20% dari total keseluruhan dataset dan random_state=1 memiliki arti jika pemilihan data testing tidak akan berubah setiap kali kita mengatur nilainya dengan 1.

model = GaussianNB()
​
model.fit(X_train, y_train)

Keterangan kode:

• model = GaussianNB(), memanggil algoritme Naïve Bayes Gausian yang diwakili oleh variabel model. Jika berhasil dijalanakn outputnya: GaussianNB()
• model.fit(X_train, y_train), untuk melatih model klasifikasi dengan data training.

y_pred = model.predict(X_test)
​
y_pred

Keterangan kode:

• y_pred = model.predict(X_test), berfungsi untuk mengembalikan hasil prediksi untuk setiap data testing dalam bentuk array.
• y_pred, menampilkan hasi prediksi. Hasilnya seperti berikut:

array([1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0])

np.array(y_test)

Keterangan kode:

• np.array(y_test), berfungsi untuk menampilkan nilai actual dari data training. Hasilnya adalah:

array([1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0])

• Jika kita perhatikan, antara hasil prediksi dan nilai actual terdapat beberapa perbedaan. Di mana pada data actual bernilai 0 namun pada array hasil prediksi bernilai 1 ataupun sebaliknya. Artinya, data yang seharusnya bernilai 0, diprediksi oleh model bernilai 1 atau sebaliknya.

confusion_matrix(y_test, y_pred)

Keterangan kode:

• confusion_matrix(y_test, y_pred), digunakan untuk mengevaluasi model dengan menggunakan fungsi confusion_matrix. Proses evaluasi dilakukan dengan menggunakan data testing sebanyak 20% yang telah kita definisikan pada proses sebelumnya. Hasilnya seperti berikut:

array([[97, 3], 
​
[ 9, 90]])

• True Positives(TP) merupakan pasien yang benar-benar positif diabetes diprediksi benar positif diabetes sebanyak 97 orang.
• True Negatives(TN) adalah pasien yang benar-benar negatif diabetes diprediksi benar negatif diabetes sebanyak 90 orang.
• False Positives(FP) yaitu pasien yang benar-benar positif diabetes diprediksi negatif diabetes sebanyak 3 orang.
• False Negatives(FN) merupakan orang yang benar-benar negatif diabetes diprediksi positif diabetes sebanyak 9 orang.
• Data yang digunakan dalam evaluasi ini merupakan data testing yang sebelumnya sudah kita atur sebanyak 20% atau 199 data dari total keseluruhan data sebanyak 995.

cv = KFold(n_splits=10, random_state=1, shuffle=True)
​
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
​
print(scores)

Keterangan kode:

• cv = KFold(n_splits=10, random_state=1, shuffle=True), kode ini mengacu pada penggunaan teknik cross-validation KFold. n_splits=10 menunjukkan bahwa data akan dibagi menjadi 10 bagian atau “fold” yang sama besar. random_state=1 menentukan bahwa hasil pembagian fold akan tetap sama jika diproses ulang dengan setting yang sama. shuffle=True menentukan bahwa urutan data pada setiap fold akan dicampur sebelum dibagi menjadi 10 bagian. Kombinasi ini digunakan untuk memastikan bahwa hasil cross-validation bisa diperoleh dengan representatif dan tidak terpengaruh oleh urutan data.
• scores = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv, n_jobs=-1), menggunakan metode cross_val_score untuk menilai akurasi dari model yang diberikan (model) dengan data X dan target y. Kode ini melakukan validasi silang dengan jumlah “folds” sebanyak cv, yang didapatkan dari objek KFold dengan jumlah “splits” sebanyak 10. Scoring yang digunakan adalah accuracy atau keakuratan. opsi n_jobs=-1 berarti melakukan parallel computing pada semua CPU yang tersedia pada sistem, untuk meningkatkan kecepatan proses. Akhirnya, hasil validasi silang akan dikumpulkan dalam variabel scores.
• print(scores), menampilkan hasil akurasi. Hasilnya seperti berikut:

[0.97  0.94  0.94  0.9  0.96  0.92929293
​
0.94949495 0.90909091 0.91919192 0.90909091]

accuracy = cross_val_score(model, X, y, scoring='accuracy', cv=cv)
​
print('Accuracy: {}'.format(accuracy.mean()*100))
​
precision = cross_val_score(model, X, y, scoring='precision_weighted', cv=cv)
​
print('Precision: {}'.format(precision.mean()*100))
​
recall = cross_val_score(model, X, y, scoring='recall_weighted', cv=cv)
​
print('Recall: {}'.format(recall.mean()*100))
​
f1 = cross_val_score(model, X, y, scoring='f1_weighted', cv=cv)
​
print('F1: {}'.format(f1.mean()*100))

Keterangan kode:

• accuracy = cross_val_score(model, X, y, scoring=’accuracy’, cv=cv) : Ini adalah perintah untuk menghitung nilai akurasi dari model klasifikasi yang dipilih dengan menggunakan teknik cross validation. Parameter yang digunakan adalah model klasifikasi (model), data fitur (X), data target (y), metode scoring menggunakan ‘accuracy’ (yaitu akurasi), dan teknik cross validation menggunakan cv (KFold). Hasil dari perhitungan ini disimpan dalam variabel accuracy.
• print(‘Accuracy: {}’.format(accuracy.mean()*100)) : Ini adalah perintah untuk mencetak nilai rata-rata akurasi model dalam bentuk presentasi persen. Nilai rata-rata diperoleh dengan memanggil method mean() pada variabel accuracy.
• precision = cross_val_score(model, X, y, scoring=’precision_weighted’, cv=cv) : Ini adalah perintah untuk menghitung nilai presisi dari model klasifikasi yang dipilih dengan menggunakan teknik cross validation. Parameter yang digunakan adalah sama seperti baris 1, namun metode scoring yang digunakan adalah ‘precision_weighted’ (yaitu presisi terbobot). Hasil dari perhitungan ini disimpan dalam variabel precision.
• print(‘Precision: {}’.format(precision.mean()*100)) : Ini adalah perintah untuk mencetak nilai rata-rata presisi model dalam bentuk presentasi persen. Nilai rata-rata diperoleh dengan memanggil method mean() pada variabel precision.
• recall = cross_val_score(model, X, y, scoring=’recall_weighted’, cv=cv) : Ini adalah perintah untuk menghitung nilai recall dari model klasifikasi yang dipilih dengan menggunakan teknik cross validation. Parameter yang digunakan adalah sama seperti baris 1, namun metode scoring yang digunakan adalah ‘recall_weighted’ (yaitu recall terbobot). Hasil dari perhitungan ini disimpan dalam variabel recall.
• print(‘Recall: {}’.format(recall.mean()*100)) : Ini adalah perintah untuk mencetak nilai rata-rata recall model dalam bentuk presentasi persen. Nilai rata-rata diperoleh dengan memanggil method mean() pada variabel recall.
• f1 = cross_val_score(model, X, y, scoring=’f1_weighted’, cv=cv): adalah baris kode untuk menghitung F1-score model dengan metode cross-validation (cv). Metric yang digunakan adalah ‘f1_weighted’ dan model yang akan diuji adalah model, dataset X dan label y.
• print(‘F1: {}’.format(f1.mean()*100)) adalah baris kode untuk mencetak hasil F1-score rata-rata dalam bentuk persentase.

Jika kode di atas berhasil dijalankan, maka akan menghasilkan output seperti berikut:

Accuracy: 93.26161616161615
​
Precision: 93.4549273514601
​
Recall: 93.26161616161615
​
F1: 93.25805159057795

Proses klasifikasi menggunakan algoritme naïve bayes sudah selesai pada tahap ini. Selanjutnya akan dilakukan pemodelan yang sama menggunakan software Orange Data mining.

3.2 Orange

Pada contoh sebelumnya, kita telah membuat model Naive Bayes menggunakan Python. Selanjutnya, kita akan mencoba mengimplementasikan contoh kasus di atas ke dalam software orange data mining. Kita asumsikan software Orange sudah dibuka dan dataset diabetes_nb.csv juga sudah diimpor ke dalam software Orange, sehingga tampilannya menjadi seperti di bawah ini:

Selanjutnya, klik dua kali widget File untuk mengetahui informasi dari dataset tersebut seperti jumlah baris, jumlah missing value, atribut yang terdapat di dalam dataset, dan lain sebagainya seperti gambar berikut:

Keterangan:

• 995 instance: dataset ini memiliki record atau tupel sebanyak 995 baris.
• 3 features (no missing values): dataset yang digunakan memiliki 3 fitur dan diidentifikasi oleh orange tidak memiliki missing value.
• Data has no target variable: menurut Orange, dataset yang kita gunakan tidak memiliki variabel target.

Berikutnya, sambungkan antara widget File dengan widget Data Table untuk melihat seluruh isi dataset dalam bentuk table. Tampilannya seperti ini:

Untuk mengetahui rincian dataset, klik dua kali pada widget Data Table kemudian akan muncul tampilan seperti ini:

Keterangan:

• Info: Penjelasannya sudah diuraikan di bagian sebelumnya.
• Show Variable Labels (if present): menampilkan variabel atau atribut label/target jika ada.
• Visualize numeric values: menampilkan nilai numerik pada setiap atribut yang bertipe data numerik.
• Color by instance classes: menandai warna berdasarkan kelas atribut targetnya.
• Select full rows: memilih baris yang dapat dikirim ke widget lain.
• Restore Original Order: Mengembalikan urutan seperti semula.

Untuk melanjutkan proses pembuatan model menggunakan algoritme naive bayes, terlebih dahulu kita harus memilih salah satu fitur sebagai fitur target. Pemilihan fitur dapat dilakukan dengan mengubah Role Feature yang terdapat pada widget File atau dengan menghubungkan widget File dengan widget Select Columns seperti berikut:

Selanjutnya, klik dua kali widget Select Columns untuk melakukan pemilihan fitur-fitur yang akan digunakan seperti gambar ini:

Keterangan:

• Ignored: Fitur yang tidak akan digunakan. Pada kasus ini, semua fitur akan kita gunakan seluruhnya.
• Features: Berisi fitur-fitur yang akan digunakan.
• Target: Fitur yang dijadikan sebagai variabel target. Pada dataset ini, fitur ‘diabetes’ yang akan kita pilih sebagai variabel target.
• Metas: Sama seperti Ignored, menu ini berisi fitur yang dianggap tidak akan digunakan.
• Reset: Mengembalikan data seperti semula (data input).
• Send Automatically: Centang menu ini jika kita ingin menerapkan perubahan secara otomatis

Setelah variabel target sudah ditentukan, berikutnya kita hubungkan widget Select Columns dengan widget Test and Score yang terdapat pada group widget Evaluate. Implementasinya seperti ini:

Jika langakah sebelumnya sudah berhasil kita lakukan, selanjutnya sambungkan antara widget Test and Score dengan widget Naive Bayes yang terdapat pada group widget Model. Hasilnya seperti berikut:

Untuk melihat hasil evaluasi model, klik dua kali pada widget Test and Score hingga muncul tampilan seperti di bawah ini:

Keterangan:

• Cross Validation: membagi data ke dalam beberapa fold (iterasi), secara umum 5 atau 10. Contoh, kita memiliki 1000 data. Jika k-fold ditentukan sebanyak 5, maka banyaknya data yang digunakan sebagai data testing sebanyak 200 dan data training sebanyak 800. Hasil ini diperoleh berdasarkan perhitungan dari 1000/5 = 200 (banyaknyaknya data/jumlah k-fold). Nilai akurasi yang dihasilkan merupakan rata-rata akurasi dari banyaknya iterasi. Pada kasus ini, kita akan menggunakan k-fold sebanyak 10.
• Random Sampling: membagi dataset secara acak menjadi data training dan testing ke dalam proporsi tertentu, misalnya 70:30. Kemudian, proses tersebut diulangi sebanyak ketentuan yang diberikan.
• Leave one out: sesuai dengan namananya, metode ini akan meninggalkan satu titik data sebagai data testing dan menggunakan data lainnya sebagai data training. Misal, kita memiliki 100 baris data. Secara otomatis, satu data akan dipilih sebagai data uji dan 99 data lainnya sebagai data latih. Proses iterasi ini akan terus dilakukan sebanyak jumlah data yang ada (pada contoh ini jumlah data sebanyak 100 data).
• Test on train data: menggunakan seluruh dataset untuk pelatihan dan pengujian.
• Test on test data: proses untuk menguji performa model klasifikasi yang telah dibangun pada data baru (test data) yang tidak digunakan selama proses pelatihan. Ini bertujuan untuk memvalidasi model klasifikasi dan menilai seberapa baik model tersebut dapat memprediksi data baru yang tidak terlihat sebelumnya.
• Model: algoritme yang digunakan untuk melakukan pemodelan.
• AUC: merupakan area di bawah kurva ROC.
• CA (Classification accuracy): seberapa akurat model dalam memprediksi semua kelas. Misalnya, berapa orang yang benar-benar diprediksi terkena diabetes dan tidak terkena diabetes berdasarkan data aktual. Pada kasus ini, akurasi model yang dihasilkan sebesar 91%.
• Precision: proporsi True Positive di antara contoh yang diklasifikasikan sebagai positif. Misalnya, proporsi positif diabetes yang diidentifikasi dengan benar sebagai positif diabetes. Pada kasus ini, precision model yang dihasilkan sebesar 91%.
• Recall: proporsi true positive di antara semua contoh positif pada data aktual. Misalnya, jumlah orang sakit di antara semua yang didiagnosa sakit. Pada kasus ini, skore recall yang dihasilkan sebesar 91%.
• F1: merupakan rata-rata dari precission dan Recall. Pada kasus ini, nilai F1 yang dihasilkan sebesar 91%.

Selain melakukan evaluasi menggunakan widget Test and Score, kita juga dapat melihat proporsi antara kelas yang diprediksi dan kelas sebenarnya dengan menyambungkan widget Tets and Score dan widget Confusion Matrix yang terdapat pada group widget Evaluate. Tampilannya seperti gambar di bawah ini:

Klik dua kali pada widget Confusion Matrix untuk melihat hasilnya seperti di bawah ini:

Keterangan:

• Learners: algoritme yang akan dievaluasi. Pada kasus ini, algoritme yang digunakan yaitu Naïve Bayes.
• Show: memilih data yang akan ditampilkan pada Confusion Matrix seperti number of instance, Proportions of predicted, dan Proportions of actual.
• Number of instances: menunjukan hasil klasifikasi (benar dan salah) secara numerik.
• Proportions predicted: menunjukkan berapa banyak data yang diklasifikasikan dengan benar.
• Proportions of actual: menunjukkan hubungan yang berlawanan.
• Select Coreect: mengirim semua contoh yang diklasifikasikan dengan benar ke output dengan memilih diagonal matriks.
• Select Misclassied: memilih menampilkan contoh misclassified.
• Clear Section: membatalkan perintah.
• Predictions: jika menu ini dicentang, akan menampilkan atribut baru berdasarkan nilai prediksi.
• Probabilities: jika menu ini dicentang, akan menampilkan atribut baru berdasarkan nilai probabilitas.
• Hasil confuction matrix di atas menunjukan model naïve bayes yang dibuat oleh Orange dapat memprediksi dengan benar pasien yang negatif diabetes sebanyak 453 orang dari total data aktual orang yang negatif diabetes sebanyak 497. Ini artinya, sebanyak 44 orang diprediksi oleh model sebagai pasien yang positif diabetes. Begitu juga untuk pasien yang positif diabetes, model dapat memprediksi dengan benar sebanyak 457 orang positif diabetes dari total data aktual orang yang positif diabetes yang berjumlah 498 orang. Hal ini menunjukkan, model memprediksi pasien yang benar-benar positif diabetes menjadi negatif diabetes sebanyak 41 pasien.

4. Hasil Evaluasi

Setelah evaluasi model dilakukan, langkah berikutnya adalah mengevaluasi hasilnya. Tahapan ini berfungsi untuk memberikan penjelasan terkait ekstraksi pengetahuan yang sudah didapatkan ketika model berhasil dibuat. Ekstraksi pengetahuan lebih mengarah pada rekomendasi keputusan apa yang harus diambil, bagaimana menentukan kebijakan yang lebih akurat berdasarkan objektif dari data yang sudah diolah sebelumnya, menambah sifat efektif dan efisien terhadap pekerjaan yang akan dilakukan.

Jika mengacu pada hasil confusion matrix sebelumnya, tertulis bahwa akurasi yang didapatkan melalui perhitungan Python dan Orange adalah 93% dan 91%. Itu artinya, jika terdapat data baru sebanyak 1000 tupel yang ingin diklasifikasikan, model Python memprediksi dengan benar sekitar 930 data dari 1000 tupel data. Sedangkan model yang diterapkan menggunakan software Orange memprediksi dengan benar sekitar 910 data dari 1000 tupel data yang baru. Hal ini menunjukkan bahwa algoritma naive bayes dapat digunakan untuk melakukan klasifikasi pada dataset diabetes dan hasilnya sudah cukup baik.

Selain akurasi, pada Python terdapat precision yang memiliki hasil 93.45%. Hasil ini dapat menjawab pertanyaan “Berapa persen pasien yang benar menderita diabetes dari keseluruhan pasien yang diprediksi menderita diabetes?”. Kemudian, nilai 93.26% pada recall dapat menjawab pertanyaan “Berapa persen pasien yang diprediksi diabetes dibandingkan keseluruhan pasien yang sebenarnya menderita diabetes”. Terakhir, nilai 93.26% yang dihasilkan oleh F1 menunjukkan bahwa model memiliki kinerja yang baik dalam memprediksi sampel positif dengan benar dan mengidentifikasi seluruh sampel positif dalam data. Penjelasan yang sama juga berlaku untuk nilai precision, recall, dan F1 yang dihasilkan oleh software Orange. Masing-masing metriks menghasilkan nilai sebesar 91%, artinya model tersebut memiliki performa yang baik dalam memprediksi kelas dari data diabetes.

Dalam benak kita mungkin akan muncul pertanyaan, mengapa akurasi yang dihasilkan oleh kedua alat tersebut berbeda? Hal ini bisa disebabkan karena parameter yang digunakan dalam teknik validasi pada python dan Orange berbeda. Jika kita perhatikan kode Python yang kita gunakan sebelumnya, pada proses evaluasi menggunakan teknik cross validation, selain mendefinisikan banyaknya k=10, kita juga mendefinisikan random_state=1, shuffle=True. Sayangnya, dalam software Orange, kita hanya diperbolehkan memberikan input banyaknya K sehingga dalam melakukan iterasi pada proses cross validation, kita menggunakan settingan default yang sudah ditentukan oleh Orange.

Sekian penjelasan singkat terkait algoritme naive bayes dan cara kerjanya di balik kode python dan software Orange. Jangan pernah menyerah karena penderitaan lainnya masih banyak yang menunggu. Jika hari ini hidupmu terasa sangat berat, mungkin kamu sedang lupa kalo kemarin kita sudah berhasil melewati fase hidup yang tak kalah berat :)