Filter Whatsapp Spam dengan Native Bayes From Scratch – Python

Assalamualaikum Sahabat Whitecyber semua …

Hari ini whitecyber team mendapatkan Project untuk mendeteksi Spam pada Whatsapp dengan Metode Native Bayes From Scratch dengan catatan tidak menggunakan modul python sklearn. Scikit-learn (Sklearn) adalah salah satu package paling berguna untuk machine learning dengan Python. Package ini menyediakan pilihan alat yang efisien untuk machine learning seperti klasifikasi, regresi, clustering, dan dimension reduction melalui antarmuka konsistensi dengan Python.

Algoritma naive bayes adalah salah satu metode klasifikasi yang berdasarkan pada teorema bayes. Teorema bayes menyatakan bahwa probabilitas suatu kejadian tergantung pada informasi yang diketahui sebelumnya. Algoritma naive bayes mengasumsikan bahwa semua fitur yang digunakan untuk klasifikasi adalah saling independen, atau tidak saling mempengaruhi. Dengan asumsi ini, algoritma naive bayes dapat menghitung probabilitas suatu kelas (label) berdasarkan nilai-nilai fitur yang diberikan.

Algoritma naive bayes memiliki beberapa kelebihan, antara lain:

Mudah diimplementasikan dan diinterpretasikan
Cepat dan efisien dalam hal komputasi dan memori
Cocok untuk data dengan dimensi tinggi atau banyak fitur
Dapat menangani data yang tidak lengkap atau memiliki nilai yang hilang
Dapat beradaptasi dengan data baru yang masuk secara online

Algoritma naive bayes juga memiliki beberapa kekurangan, antara lain:

Asumsi independensi fitur mungkin tidak selalu valid dalam praktiknya
Dapat menghasilkan probabilitas yang tidak akurat jika ada fitur yang berkorelasi tinggi
Dapat rentan terhadap bias jika ada kelas atau fitur yang jarang muncul dalam data

Algoritma naive bayes dapat digunakan untuk berbagai aplikasi klasifikasi, seperti:

Deteksi spam email
Analisis sentimen teks
Rekomendasi produk
Diagnosa medis
Pengenalan wajah

Algoritma Naive Bayes: Definisi dan Contoh Penerapannya

Mengenal apa itu algoritma Naive Bayes yang kerap digunakan dalam pelatihan data machine learning. Seperti apa contoh penerapannya?

Naive Bayes adalah kumpulan algoritma yang disusun berdasarkan Teorema Bayes. Nah, Teorema Bayes sendiri merupakan model matematika dengan dasar statistik dan probabilitas. Meski bukan suatu hal yang baru, algoritma ini tetap relevan dengan machine learning (ML) yang berkembang belakangan ini, terutama yang masih berkaitan dengan masalah NLP atau natural language processing. Namun, sebenarnya apa itu algoritma Naive Bayes?

Apa Itu Naive Bayes?

Naive Bayes, atau kadang disebut Naïve Bayes Classifier, adalah algoritma machine learning probabilistik yang digunakan dalam berbagai macam tugas klasifikasi. Untuk bisa memahami algoritma ini, berikut rumus umum Teorema Bayes yang menjadi dasar dari Naive Bayes berikut:

Sederhananya, Teorema Bayes membantu Anda untuk bisa mengetahui sebuah probabilitas dengan menghitung probabilitas lain yang masih berkaitan. Setelah diterapkan pada algoritma Naive Bayes, rumus ini menghasilkan suatu asumsi dasar. Dalam melihat sebuah fitur, algoritma ini selalu berasumsi bahwa fitur tersebut mandiri, setara, dan memiliki kontribusi pada hasil.

Tujuan dan Contoh Penerapan Naive Bayes
Meski terkadang tampak terlalu disederhanakan, metode klasifikasi dengan Naive Bayes ini amat relevan dengan berbagai situasi di dunia nyata. Misalnya dalam hal klasifikasi dokumen atau penyaringan pesan sampah (spam). Ini karena Naive Bayes hanya membutuhkan sejumlah kecil data yang dilatih untuk bisa memperkirakan parameter yang dibutuhkan.

Contoh penerapannya pun sangat luas. Salah satu contoh yang kerap Anda nikmati hasilnya adalah prakiraan cuaca (weather forecasting). Dengan melihat probabilitas suhu, kelembapan, dan tekanan udara, maka institusi seperti BMKG dapat memprediksi cuaca pada tanggal tertentu, apakah cerah, berawan, atau justru hujan deras.

Selain itu, Naive Bayes juga diimplementasikan dalam analisis tindak penipuan internal perusahaan. Dari data tagihan yang diajukan oleh karyawan untuk penggantian pengeluaran (reimburse), perusahaan bisa memprediksi kemungkinan penipuan. Mereka mempelajari probabilitas reimburse yang sesuai untuk kemudian memprediksi probabilitas reimburse yang dilebih-lebihkan.

Tipe-tipe Naive Bayes Classifier

Ada tiga tipe Naive Bayes Classifier yang dapat diterapkan dalam data science, tepatnya dalam pelatihan machine learning. Berikut penjelasan untuk masing-masing tipe:

Multinomial Naive Bayes
Tipe yang pertama adalah Multinomial Naive Bayes. Tipe ini banyak digunakan untuk menyelesaikan masalah klasifikasi dokumen. Algoritma ini akan membantu Anda mengetahui kategori suatu dokumen, apakah termasuk dokumen penting, dokumen yang dapat dialihkan, atau justru dokumen sampah yang berbahaya. Selain itu, bisa juga digunakan untuk mengelompokkan dokumen berdasarkan tema tertentu seperti olahraga, gaya hidup, atau sosial-politik. Fitur yang digunakan oleh classifier adalah frekuensi kata yang ada dalam dokumen. Misalnya, jika suatu dokumen terus menerus menampilkan kata “sepak bola”, “liga”, “pertandingan”, maka bisa dimasukkan dalam kategori olahraga.
Bernoulli Naive Bayes
Bernoulli Naive Bayes sebenarnya mirip dengan Multinomial Naive Bayes. Perbedaannya terletak pada fitur atau prediktornya. Alih-alih menggunakan frekuensi kata, algoritma ini menggunakan variabel boolean. Parameter yang kita gunakan untuk memprediksi variabel kelas hanya mengambil nilai ya atau tidak. Misalnya, untuk menentukan suatu dokumen masuk dalam kategori olahraga, bisa dengan mengidentifikasi apakah kata “pertandingan” muncul atau tidak. Jika kata tersebut muncul, maka dokumen secara otomatis diklasifikasikan sebagai dokumen tentang olahraga. Begitu pun sebaliknya.
Gaussian Naive Bayes
Terakhir ada Gaussian Naive Bayes. Ciri khasnya adalah ketika fitur atau prediktor mengambil nilai yang kontinu (tidak diskrit). Tiap fitur diasumsikan telah tersalurkan menurut distribusi Gaussian. Saat data diplot, maka akan menampilkan sebuah kurva dengan bentuk lonceng yang simetris. Kurva tersebut menunjukkan rata-rata nilai fitur.

Project Detail

Server : Anaconda
Framework : Jupyter Notebook
Language : Python
Database : Csv – Exell.

Starting

Dalam postingan Research ini, kita akan membuat filter spam menggunakan Python dan algoritma Naive Bayes multinomial . Sasaran kami adalah membuat kode filter spam dari awal yang mengklasifikasikan pesan dengan akurasi lebih dari 80%.

Untuk membuat filter spam, kami akan menggunakan kumpulan data 5.572 pesan SMS. Kumpulan data ini bisa kita terapkan untuk Whatsapp, Telegram, BBM, dll. Tiago A. Almeida dan José María Gómez Hidalgo mengumpulkan kumpulan data, Anda dapat mengunduhnya dari Repositori Pembelajaran Mesin UCI .

Kami akan fokus pada implementasi Python di seluruh postingan, jadi kami berasumsi bahwa Anda sudah familiar dengan multinomial Naive Bayes dan proabilitas bersyarat.

Exploring the Dataset

Mari kita mulai dengan membuka WASpamCollection file dengan read_csv() fungsi dari paketnya pandas . Kami akan menggunakan:

sep=’\t’ karena titik datanya dipisahkan tab
header=None karena dataset tidak memiliki baris header
names=[‘Label’, ‘WA’] untuk memberi nama kolom

Source Code

import pandas as pd
wa_spam = pd.read_csv(r"C:\Users\GK3v\Documents\Python\NaiveBayesTfidf\smsspamcollection\WASpamCollection", sep='\t', header=None, names=['Label', 'WA'])
print(wa_spam.shape)

(5572, 2)

wa_spam.head()

	Label	WA
0	ham	Go until jurong point, crazy.. Available only ...
1	ham	Ok lar... Joking wif u oni...
2	spam	Free entry in 2 a wkly comp to win FA Cup fina...
3	ham	U dun say so early hor... U c already then say...
4	ham	Nah I don't think he goes to usf, he lives aro...

wa_spam['Label'].value_counts(normalize=True)

Label
ham 0.865937
spam 0.134063
Name: proportion, dtype: float64

Analisa Pertama
Di atas, kita melihat bahwa sekitar 87% pesan adalah ham (non-spam), dan 13% sisanya adalah spam. Sampel ini terlihat representatif, karena dalam praktiknya sebagian besar pesan yang diterima masyarakat adalah pesan ham.

Training and Test Set

Kami sekarang akan membagi kumpulan data kami menjadi training set dan test set. Kami akan menggunakan 80% data untuk pelatihan dan 20% sisanya untuk pengujian. Kami akan mengacak seluruh kumpulan data sebelum memisahkannya untuk memastikan pesan spam dan ham tersebar dengan baik ke seluruh kumpulan data.

# Mengacak dataset
data_randomized = wa_spam.sample(frac=1, random_state=1)

# Menghitung index untuk pemisahan
training_test_index = round(len(data_randomized) * 0.8)

# Membagi menjadi training sets and test sets
training_set = data_randomized[:training_test_index].reset_index(drop=True)
test_set = data_randomized[training_test_index:].reset_index(drop=True)

print(training_set.shape)
print(test_set.shape)

(4458, 2)
(1114, 2)

Kami sekarang akan menganalisis persentase pesan spam dan ham di set pelatihan dan pengujian. Kami perkirakan persentasenya akan mendekati dataset lengkap yang kami miliki, yaitu sekitar 87% pesan adalah ham, dan 13% sisanya adalah spam.

training_set['Label'].value_counts(normalize=True)

Label
ham 0.86541
spam 0.13459
Name: proportion, dtype: float64

test_set['Label'].value_counts(normalize=True)

Label
ham     0.868043
spam    0.131957
Name: proportion, dtype: float64

Hasilnya terlihat bagus! Kami sekarang akan melanjutkan untuk membersihkan kumpulan data.

Data Cleaning

Ketika ada pesan baru yang masuk, algoritma Naive Bayes multinomial kami akan membuat klasifikasi berdasarkan hasil yang didapat dari dua persamaan di bawah ini, dimana “w 1 ” adalah kata pertama, dan w 1 ,w 2 , …, w n adalah keseluruhan pesan:

Jika P(Spam | w 1 ,w 2 , …, w n ) lebih besar dari P(Ham | w 1 ,w 2 , …, w n ), maka pesan tersebut adalah spam.

Untuk menghitung P(w i |Spam) dan P(w i |Ham), kita perlu menggunakan persamaan terpisah:

Mari kita perjelas beberapa istilah dalam persamaan ini:

Untuk menghitung semua probabilitas ini, pertama-tama kita perlu melakukan sedikit pembersihan data untuk membawa data ke dalam format yang memungkinkan kita mengekstrak semua informasi yang kita perlukan dengan mudah. Saat ini, set pelatihan dan pengujian kami memiliki format berikut (pesan di bawah ini fiktif agar contoh lebih mudah dipahami):

Untuk mempermudah perhitungan, kami ingin membawa data ke format ini (tabel di bawah adalah transformasi dari tabel yang Anda lihat di atas):

.
Perhatikan transformasi di atas :

Kolom tersebut SMS/WA diganti dengan serangkaian kolom baru yang mewakili kata-kata unik dari kosakata — kosakata adalah kumpulan kata-kata unik dari seluruh kalimat kita.
Setiap baris menjelaskan satu pesan. Baris pertama memiliki nilai spam, 2, 2, 1, 1, 0, 0, 0, 0, 0, yang memberi tahu kita bahwa:

Pesannya adalah spam.
Kata “secret” muncul dua kali di dalam pesan.
Kata “prize” muncul dua kali di dalam pesan.
Kata “claim” muncul satu kali di dalam pesan.
Kata “now” muncul satu kali di dalam pesan.
Kata-kata “coming,” “to,” “my,” “party,” dan “winner” muncul nol kali di dalam pesan.
Semua kata dalam kosakata menggunakan huruf kecil, jadi “SECRET” dan “secret” dianggap sebagai kata yang sama.
Urutan kata pada kalimat aslinya hilang.
Tanda baca tidak lagi diperhitungkan (misalnya, kita tidak dapat melihat tabel dan menyimpulkan bahwa pesan pertama awalnya memiliki dua tanda seru).

Letter Case and Punctuation / Huruf Besar dan Tanda Baca

Mari kita mulai proses pembersihan data dengan menghilangkan tanda baca dan membuat semua kata menjadi huruf kecil.

# Sebelum membersihkan 
training_set.head(3)

# Setelah membersihkan
training_set['WA'] = training_set['WA'].str.replace('\W', ' ') # Menghapus Tanda Baca
training_set['WA'] = training_set['WA'].str.lower()
training_set.head(3)

Creating the Vocabulary / Menciptakan Kosakata

Sekarang mari kita buat kosakata, yang dalam konteks ini berarti daftar semua kata unik dalam set pelatihan kita. Dalam kode di bawah ini:

Kami mengubah setiap pesan di WA kolom menjadi daftar dengan memisahkan string pada karakter spasi — kami menggunakan Series.str.split() metode ini .
Kami memulai daftar kosong bernama vocabulary.
Kami mengulangi WA kolom yang diubah.
Dengan menggunakan loop bersarang, kami mengulangi setiap pesan di WA kolom dan menambahkan setiap string (kata) ke vocabulary daftar.
Kami mengubah vocabulary daftar menjadi satu set menggunakan set() function . Ini akan menghapus duplikat dari vocabulary daftar.
Kami mengubah vocabulary set kembali menjadi daftar menggunakan list() function.

training_set['WA'] = training_set['WA'].str.split()

vocabulary = []
for wa in training_set['WA']:
for word in wa:
vocabulary.append(word)

vocabulary = list(set(vocabulary))

len(vocabulary)

11860

Sepertinya ada 11.860 kata unik di semua pesan training set kami.

The Final Training Set

Kita sekarang akan menggunakan kosakata yang baru saja kita buat untuk melakukan transformasi data yang kita inginkan.

Akhirnya, kita akan membuat DataFrame baru. Pertama-tama kita akan membuat kamus yang kemudian akan kita konversi ke DataFrame yang kita perlukan.
Misalnya, untuk membuat tabel yang kita lihat di atas, kita dapat menggunakan kamus ini:

word_counts_per_wa = {'secret': [2,1,1],
'prize': [2,0,1],
'claim': [1,0,1],
'now': [1,0,1],
'coming': [0,1,0],
'to': [0,1,0],
'my': [0,1,0],
'party': [0,1,0],
'winner': [0,0,1]
}

word_counts = pd.DataFrame(word_counts_per_wa)
word_counts.head()

Untuk membuat kamus yang kita perlukan untuk training set kita, kita dapat menggunakan kode di bawah ini:

Kita mulai dengan menginisialisasi kamus bernama word_counts_per_wa, di mana setiap kunci adalah kata unik (string) dari kosakata, dan setiap nilai adalah daftar panjang training set, di mana setiap elemen dalam daftar tersebut adalah a 0.
Kodenya [0] * 5 keluar [0, 0, 0, 0, 0]. Jadi kode tersebut [0] * len(training_set[‘WA’]) menampilkan daftar dengan panjang training_set[‘WA’].
Kita mengulang training_set[‘WA’] penggunaan enumerate() fungsi tersebut untuk mendapatkan indeks dan pesan WA ( index dan WA).
Dengan menggunakan loop bersarang, kita melakukan loop wa (di mana sms adalah daftar string, di mana setiap string mewakili sebuah kata dalam pesan).
Kami bertambah word_counts_per_wa[word][index] sebesar 1.

word_counts_per_wa = {unique_word: [0] * len(training_set['WA']) for unique_word in vocabulary}

for index, wa in enumerate(training_set['WA']):
for word in wa:
word_counts_per_wa[word][index] += 1

Sekarang kita sudah memiliki kamus yang kita perlukan, mari kita lakukan transformasi terakhir pada set pelatihan kita.

word_counts = pd.DataFrame(word_counts_per_wa)
word_counts.head()

Kolomnya Label tidak ada, jadi kita akan menggunakan pd.concat() function tersebut untuk menggabungkan DataFrame yang baru saja kita buat dengan DataFrame yang berisi set pelatihan. Dengan cara ini, kita juga akan memiliki kolom Label dan WA .

Menghitung Konstanta Terlebih Dahulu / Calculating Constants First

Sekarang setelah kita selesai membersihkan set pelatihan, kita dapat mulai mengkodekan filter spam. Algoritme multinomial Naive Bayes perlu menjawab dua pertanyaan probabilitas berikut agar dapat mengklasifikasikan pesan baru:

Selain itu, untuk menghitung P(w i |Spam) dan P(w i |Ham) di dalam rumus di atas, kita perlu menggunakan persamaan berikut:

Beberapa istilah dalam empat persamaan di atas akan mempunyai nilai yang sama untuk setiap pesan baru. Kita dapat menghitung nilai suku-suku ini satu kali dan menghindari melakukan penghitungan lagi ketika ada pesan baru yang masuk. Sebagai permulaan, mari kita hitung terlebih dahulu:

P(Spam) dan P(Ham)
N Spam , N Ham , N Kosakata

Penting untuk diperhatikan bahwa:

N Spam sama dengan jumlah kata dalam semua pesan spam — tidak sama dengan jumlah pesan spam, dan tidak sama dengan jumlah total kata unik dalam pesan spam.
N Ham sama dengan jumlah kata dalam semua pesan non-spam — tidak sama dengan jumlah pesan non-spam, dan tidak sama dengan jumlah total kata unik dalam pesan non-spam.
Kami juga akan menggunakan penghalusan dan penyetelan .

# Isolating spam and ham messages first
spam_messages = training_set_clean[training_set_clean['Label'] == 'spam']
ham_messages = training_set_clean[training_set_clean['Label'] == 'ham']

# P(Spam) and P(Ham)
p_spam = len(spam_messages) / len(training_set_clean)
p_ham = len(ham_messages) / len(training_set_clean)

# N_Spam
n_words_per_spam_message = spam_messages['WA'].apply(len)
n_spam = n_words_per_spam_message.sum()

# N_Ham
n_words_per_ham_message = ham_messages['WA'].apply(len)
n_ham = n_words_per_ham_message.sum()

# N_Vocabulary
n_vocabulary = len(vocabulary)

# Laplace smoothing
alpha = 1

Menghitung Parameter / Calculating Parameter

Sekarang kita telah menghitung suku konstanta di atas, kita dapat melanjutkan dengan menghitung parameter P(w i |Spam) dan P(w i |Ham).

Oleh karena itu, setiap parameter akan menjadi nilai probabilitas bersyarat yang terkait dengan setiap kata dalam kosakata.

Parameter dihitung menggunakan dua persamaan berikut:

# Initiate parameters
parameters_spam = {unique_word:0 for unique_word in vocabulary}
parameters_ham = {unique_word:0 for unique_word in vocabulary}

# Calculate parameters
for word in vocabulary:
n_word_given_spam = spam_messages[word].sum() # spam_messages already defined
p_word_given_spam = (n_word_given_spam + alpha) / (n_spam + alpha*n_vocabulary)
parameters_spam[word] = p_word_given_spam

n_word_given_ham = ham_messages[word].sum() # ham_messages already defined
p_word_given_ham = (n_word_given_ham + alpha) / (n_ham + alpha*n_vocabulary)
parameters_ham[word] = p_word_given_ham

Mengklasifikasikan Pesan Baru / Classifying A New Message

Sekarang setelah semua parameter dihitung, kita dapat mulai membuat filter spam. Filter spam dipahami sebagai fungsi yang:

Menerima pesan baru sebagai masukan (w 1 , w 2 , …, w n ).
Menghitung P(Spam|w 1 , w 2 , …, w n ) dan P(Ham|w 1 , w 2 , …, w n ).
Membandingkan nilai P(Spam|w 1 , w 2 , …, w n ) dan P(Ham|w 1 , w 2 , …, w n ), dan:
Jika P(Ham|w 1 , w 2 , …, w n ) > P(Spam|w 1 , w 2 , …, w n ), maka pesan tersebut diklasifikasikan sebagai ham.
Jika P(Ham|w 1 , w 2 , …, w n ) < P(Spam|w 1 , w 2 , …, w n ), maka pesan tersebut diklasifikasikan sebagai spam.
Jika P(Ham|w 1 , w 2 , …, w n ) = P(Spam|w 1 , w 2 , …, w n ), maka algoritma dapat meminta bantuan manusia.

Perhatikan bahwa beberapa pesan baru akan berisi kata-kata yang bukan bagian dari kosakata. Kita akan mengabaikan kata-kata ini saat menghitung probabilitas.

Mari kita mulai dengan menulis versi pertama dari fungsi ini. Untuk classify() fungsi di bawah ini, perhatikan bahwa:

Variabel masukan message harus berupa string.
Kami melakukan sedikit pembersihan data pada string message:
Kami menghapus tanda baca menggunakan re.sub() fungsi .
Kami mengubah semua huruf menjadi huruf kecil menggunakan str.lower() metode ini .
Kami membagi string pada karakter spasi dan mengubahnya menjadi daftar Python menggunakan str.split() metode ini .
Kami menghitung p_spam_given_message dan p_ham_given_message.
Kami membandingkan p_spam_given_message dan p_ham_given_message kemudian mencetak label klasifikasi.

import re

def classify(message):
'''
message: a string
'''

message = re.sub('\W', ' ', message)
message = message.lower().split()

p_spam_given_message = p_spam
p_ham_given_message = p_ham

for word in message:
if word in parameters_spam:
p_spam_given_message *= parameters_spam[word]

if word in parameters_ham: 
p_ham_given_message *= parameters_ham[word]

print('P(Spam|message):', p_spam_given_message)
print('P(Ham|message):', p_ham_given_message)

if p_ham_given_message > p_spam_given_message:
print('Label: Ham')
elif p_ham_given_message < p_spam_given_message:
print('Label: Spam')
else:
print('Equal proabilities, have a human classify this!')

Kami sekarang akan menguji filter spam pada dua pesan baru. Satu pesan jelas-jelas spam, dan pesan lainnya jelas-jelas ham.

classify('WINNER!! This is the secret code to unlock the money: C3421.')

Hasilnya

P(Spam|message): 1.1680023632078457e-26
P(Ham|message): 6.088544142463393e-28
Label: Spam

classify("Sounds good, Tom, then see u there")

Hasilnya

P(Spam|message): 2.234299283967944e-26
P(Ham|message): 8.376346103813855e-22
Label: Ham

Mengukur Akurasi Filter Spam / Measuring the Spam Filter’s Accuracy

Kedua hasil tersebut terlihat menjanjikan, namun mari kita lihat seberapa baik kinerja filter pada set pengujian kami, yang memiliki 1.114 pesan.

Kita akan mulai dengan menulis fungsi yang mengembalikan label klasifikasi alih-alih mencetaknya.

def classify_test_set(message):
'''
message: a string
'''

message = re.sub('\W', ' ', message)
message = message.lower().split()

p_spam_given_message = p_spam
p_ham_given_message = p_ham

for word in message:
if word in parameters_spam:
p_spam_given_message *= parameters_spam[word]

if word in parameters_ham:
p_ham_given_message *= parameters_ham[word]

if p_ham_given_message > p_spam_given_message:
return 'ham'
elif p_spam_given_message > p_ham_given_message:
return 'spam'
else:
return 'needs human classification'

Sekarang kita memiliki fungsi yang mengembalikan label alih-alih mencetaknya, kita bisa menggunakannya untuk membuat kolom baru di set pengujian kita.

test_set['predicted'] = test_set['WA'].apply(classify_test_set)
test_set.head()

Kami dapat membandingkan nilai prediksi dengan nilai sebenarnya untuk mengukur seberapa baik filter spam kami dalam mengklasifikasikan pesan baru. Untuk melakukan pengukuran, kami akan menggunakan akurasi sebagai metrik:

correct = 0
total = test_set.shape[0]

for row in test_set.iterrows():
row = row[1]
if row['Label'] == row['predicted']:
correct += 1

print('Correct:', correct)
print('Incorrect:', total - correct)
print('Accuracy:', correct/total)

Correct: 1090
Incorrect: 24
Accuracy: 0.9784560143626571

Akurasinya mendekati 97,84%, yang sangat bagus. Filter spam kami memeriksa 1.114 pesan yang belum dilihatnya dalam pelatihan, dan mengklasifikasikan 1.090 pesan dengan benar.

Hasil Akhir

Langkah selanjutnya, Dalam postingan penelitian ini, kami berhasil membuat kode filter spam untuk pesan WA menggunakan algoritma multinomial Naive Bayes. Filter tersebut memiliki akurasi 97,84% pada set pengujian yang kami gunakan, yang merupakan hasil yang menjanjikan. Sasaran awal kami adalah akurasi lebih dari 80%, dan kami berhasil mencapainya.

Beberapa langkah selanjutnya yang dapat Anda lakukan antara lain:

Menganalisis 14 pesan yang diklasifikasikan secara salah dan mencoba mencari tahu mengapa algoritma mengklasifikasikannya secara salah
Membuat proses pemfilteran menjadi lebih kompleks dengan membuat algoritme peka terhadap huruf besar-kecil

Kesimpulan

Algoritma Naive Bayes sebagian besar digunakan dalam penyaringan pesan spam, analisis sentimen, hingga sistem rekomendasi. Salah satu alasan utama penggunaan algoritma ini adalah karena implementasinya yang cepat dan mudah. Namun, sayangnya, Naive Bayes membutuhkan fitur atau prediktor independen. Padahal dalam kenyataannya, prediktor lebih sering bersifat dependen. Otomatis hal ini dapat menghambat kinerja.

Naive Bayes berhubungan erat dengan klasifikasi dan machine learning. Algoritma ini juga kerap digunakan dalam sistem rekomendasi karena dinilai efisien. Apakah Anda berniat merancang sistem rekomendasi untuk mengoptimalkan kinerja bisnis? Mempelajari data science adalah solusinya. Tidak perlu khawatir, kini telah tersedia kelas data science dengan berbagai tingkatan di Komunitas Whitecyber. Kami juga menawarkan pelatihan untuk meningkatkan skill karyawan Anda. Untuk informasi mengenai pendaftaran, hubungi teamWA kami.

Referensi:

Geeks for Geeks – Naive Bayes Classifiers
Towards Data Science – Naive Bayes Classifiers
KDnuggets – Naïve Bayes Algorithm: Everything You Need to Know
Dataversity – What is Naive Bayes Classification?

SUBMIT PROJECTS

Filter Whatsapp Spam dengan Native Bayes From Scratch – Python

Leave a Reply Cancel reply

Projects

Need help

Community

CART

WISHLIST

RECENTLY VIEWED

SUBMIT PROJECTS