Cara Membuat Detektor Email Spam dengan Python dan Naive Bayes Classifier

Pernahkah Anda bertanya-tanya bagaimana Gmail tahu bahwa email yang menjanjikan $10 juta adalah spam? Atau bagaimana cara menangkap pesan "Anda memenangkan iPhone gratis!" sebelum mencapai inbox Anda?

Dalam tutorial ini, Anda akan membuat classifier email spam sendiri dari awal menggunakan algoritma Naive Bayes. Pada akhirnya, Anda akan memiliki model yang berfungsi dengan akurasi lebih dari 97%—dan Anda akan memahami dengan tepat bagaimana cara kerjanya.

📋 Apa yang Akan Anda Pelajari

• Bagaimana filter spam email sebenarnya bekerja
• Intuisi di balik algoritma Naïve Bayes
• Teknik preprocessing teks untuk machine learning
• Cara mengevaluasi model klasifikasi
• Membangun pipeline deteksi spam lengkap dengan Python

📚 Prasyarat

Anda harus memiliki pemahaman dasar tentang Python dan beberapa pemahaman tentang konsep fundamental machine learning. Jangan khawatir jika Anda masih belajar—saya akan menjelaskan semuanya seiring berjalannya waktu.

🤔 Mengapa Naive Bayes untuk Deteksi Spam?

Sebelum kita menyelami kode, mari pahami mengapa Naive Bayes sangat cocok untuk tugas ini.

Bayangkan Anda menerima email yang berisi kata-kata seperti "gratis," "pemenang," "klik di sini," dan "penawaran waktu terbatas." Otak Anda langsung menandai ini sebagai mencurigakan. Algoritma Naive Bayes melakukan sesuatu yang serupa—algoritma ini menghitung probabilitas bahwa sebuah email adalah spam berdasarkan kata-kata yang dikandungnya.

Algoritma ini disebut "naive" (naif) karena membuat asumsi penyederhanaan: memperlakukan setiap kata sebagai independen dari kata lainnya. Pada kenyataannya, kombinasi kata penting (pikirkan "uji coba gratis" vs "uang gratis"), tetapi penyederhanaan ini bekerja dengan sangat baik dalam praktik.

✅ Mengapa Memilih Naive Bayes?

• Kecepatan: Melatih dengan sangat cepat, bahkan pada dataset besar
• Efisiensi: Membutuhkan data pelatihan minimal untuk menghasilkan hasil yang andal
• Kesederhanaan: Mudah diimplementasikan dan diinterpretasikan
• Performa: Meskipun sederhana, sering mengungguli algoritma yang lebih kompleks untuk klasifikasi teks

⚠️ Keterbatasan yang Perlu Diingat

• Asumsi independensi berarti tidak dapat menangkap hubungan antar kata
• Jika sebuah kata muncul dalam data pengujian tetapi tidak pernah muncul dalam pelatihan, algoritma menetapkan probabilitas nol

⚙️ Cara Menyiapkan Lingkungan Anda

Pertama, instal library yang diperlukan. Buka terminal Anda atau jalankan ini di sel Jupyter notebook:

%pip install regex wordcloud numpy pandas seaborn matplotlib scikit-learn

Berikut ringkasan singkat tentang apa yang dilakukan setiap library:

Library	Fungsi
regex / re	Membersihkan teks menggunakan pencocokan pola
wordcloud	Memvisualisasikan kata-kata yang paling sering muncul
numpy & pandas	Pemuatan dan manipulasi data
seaborn & matplotlib	Bagan dan visualisasi
scikit-learn	Classifier Naive Bayes, vectorizer, dan alat evaluasi

Setelah instalasi selesai, impor semua library di bagian atas skrip atau notebook Anda:

# Manipulasi dan analisis data
import pandas as pd
import numpy as np

# Visualisasi data
import seaborn as sns
import matplotlib.pyplot as plt

# Pemrosesan bahasa alami
import nltk
import re
from nltk.corpus import stopwords

# Machine learning
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

# Visualisasi word cloud
from wordcloud import WordCloud

📂 Cara Memuat dan Menjelajahi Dataset

Kami akan menggunakan dataset email yang berlabel. Anda dapat mengunduhnya dari Kaggle atau menggunakan dataset email serupa dengan kolom teks dan spam.

Gunakan fungsi read_csv() pandas untuk memuat dataset dari file CSV ke dalam DataFrame:

message_dataset = pd.read_csv('emails.csv')
message_dataset.head()

Dataset berisi 5.728 email dengan dua kolom: text (konten email) dan spam (1 untuk spam, 0 untuk email yang sah).

📊 Cara Memvisualisasikan Distribusi Data

Sebelum melatih model, penting untuk memahami data Anda. Mari kita lihat distribusi spam dan email yang sah:

plt.rcParams["figure.figsize"] = [8, 10]
message_dataset.spam.value_counts().plot(kind="pie", autopct="%1.0f%%")

Distribusi data: 24% spam, 76% email sah

Sekitar 24% email dalam dataset adalah spam, sementara 76% adalah email sah. Ini adalah dataset yang cukup tidak seimbang.

☁️ Cara Menganalisis Pola Kata dengan Word Clouds

Word cloud memberikan visualisasi intuitif dari kata-kata yang paling sering muncul. Mari kita buat word cloud terpisah untuk spam dan email yang sah:

stop = stopwords.words("english")

message_dataset["text_without_sw"] = message_dataset["text"].apply(
    lambda x: " ".join([item for item in x.split() if item not in stop])
)

Word Cloud Email Spam:

Kata-kata yang sering muncul di email spam

Word Cloud Email Sah:

Kata-kata yang sering muncul di email yang sah

🔍 Observasi Utama:

• Email spam: "free," "money," "offer," "click," "please"
• Email sah: "company," "time," "thanks," "enron"

🧹 Cara Preprocessing Data Teks

Teks mentah perlu dibersihkan sebelum algoritma machine learning dapat memprosesnya. Mari kita buat fungsi untuk membersihkan teks:

def clean_text(doc):
    document = re.sub('[^a-zA-Z]', ' ', doc)
    document = re.sub(r'\s+[a-zA-Z]\s+', ' ', document)
    document = re.sub(r'\s+', ' ', document)
    return document

🔢 Cara Mengonversi Teks ke Fitur Numerik

Algoritma machine learning bekerja dengan angka, bukan teks. Kita menggunakan TF-IDF (Term Frequency-Inverse Document Frequency) untuk mengubah teks menjadi representasi numerik:

vectorizer = TfidfVectorizer(
    max_features=2500,
    min_df=5,
    max_df=0.7,
    stop_words=stopwords.words('english')
)

X = vectorizer.fit_transform(X_sentences).toarray()

🤖 Cara Melatih Classifier Naive Bayes

Sekarang bagian yang menarik—melatih model kita!

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.20,
    random_state=42
)

spam_detector = MultinomialNB()
spam_detector.fit(X_train, y_train)

📈 Cara Mengevaluasi Performa Model

y_pred = spam_detector.predict(X_test)

print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))
print(accuracy_score(y_test, y_pred))

🎯 Akurasi Model: 97.82%

Model berhasil mengklasifikasikan email dengan tingkat akurasi yang sangat tinggi!

Confusion Matrix:

	Predicted: Sah	Predicted: Spam
Actual: Sah	849 (TN)	7 (FP)
Actual: Spam	18 (FN)	272 (TP)

🧪 Cara Menguji Email Individual

print(spam_detector.predict(vectorizer.transform([X_sentences[56]])))

Output: [1] ✅ Model dengan benar mengidentifikasi email promosi sebagai SPAM!

🎓 Kesimpulan

Anda telah membangun classifier email spam yang mencapai lebih dari 97% akurasi menggunakan algoritma Naïve Bayes. Di sepanjang jalan, Anda belajar tentang:

• ✅ Preprocessing teks
• ✅ Ekstraksi fitur dengan TF-IDF
• ✅ Teknik evaluasi model

Keindahan pendekatan ini adalah kesederhanaannya. Hanya dengan beberapa lusin baris kode, Anda telah membuat sesuatu yang benar-benar bekerja—dan sekarang Anda memahami prinsip-prinsip di balik filter spam komersial.

🚀 Langkah Selanjutnya

Ingin meningkatkan detektor spam ini lebih lanjut? Berikut beberapa ide:

• Bereksperimen dengan vectorizer berbeda: Coba CountVectorizer atau word embeddings (Word2Vec, GloVe)
• Tangani ketidakseimbangan kelas: Gunakan teknik seperti SMOTE atau sesuaikan class weights
• Feature engineering: Tambahkan fitur seperti panjang email, jumlah link, atau domain pengirim
• Coba algoritma lain: Bandingkan dengan SVM, Random Forest, atau gradient boosting
• Deploy model: Bangun API sederhana menggunakan Flask atau FastAPI

---

Sumber: freeCodeCamp - Diterjemahkan ke Bahasa Indonesia