Penghalusan Laplace dan Masalah Probabilitas Nol
Peserta didik akan mengulangi kegagalan probabilitas nol pada kata yang belum pernah dilihat dan melihat cara penghalusan Laplace mencegah model memberikan probabilitas nol.
Penghalusan Laplace dan Masalah Probabilitas Nol adalah pelajaran Machine Learning Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Machine Learning Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Machine Learning Academy mencakup 4 pelajaran total.
Bencana Probabilitas Nol
Naive Bayes menghitung probabilitas posterior suatu kelas dengan mengalikan kemungkinan semua fitur: P(class|features) ∝ P(class) * product of P(feature_i | class). Jika satu fitur saja memiliki probabilitas nol untuk suatu kelas—karena fitur tersebut tidak pernah muncul dalam data pelatihan kelas itu—seluruh hasil perkalian menjadi nol, terlepas dari fitur lainnya. Ini berarti satu kata yang belum pernah terlihat membuat pengklasifikasi tidak mampu membedakan kelas untuk dokumen tersebut. Inilah masalah probabilitas nol, yang sangat parah pada data teks karena kosakata saat pengujian hampir selalu mencakup kata-kata yang tidak terlihat selama pelatihan.
import numpy as np
# Training: 'bitcoin' never appeared in spam class
# Test document: 'buy bitcoin now cheap'
words_in_test = ['buy', 'bitcoin', 'now', 'cheap']
# Training probabilities (hypothetical)
P_word_given_spam = {'buy': 0.3, 'bitcoin': 0.0, 'now': 0.2, 'cheap': 0.4}
# Multiply likelihoods
product = 1.0
for word in words_in_test:
prob = P_word_given_spam.get(word, 0.0)
product *= prob
print(f'After {word}: product = {product}')
print('Final P(features|spam) =', product) # ZERO -- catastrophic!Mengapa Probabilitas Nol Merusak Model
Ketika P(features|class) = 0 untuk beberapa kelas sekaligus (yang terjadi jika terdapat kata-kata yang belum pernah terlihat), pengklasifikasi tidak dapat membedakan kelas-kelas tersebut—semua probabilitas posterior bernilai 0. Jika hanya sebagian kelas yang memiliki probabilitas nol, pengklasifikasi terpaksa memilih kelas yang tersisa, yang mungkin saja salah. Ini bukan sekadar kendala numerik—ini adalah kegagalan model yang mendasar. Dalam ruang logaritmik, probabilitas nol menjadi negatif tak terhingga: log(0) = -infinity. Penjumlahan dengan nilai yang berhingga tetap menghasilkan negatif tak terhingga, sehingga probabilitas logaritmik sepenuhnya didominasi oleh satu nilai nol ini dan mengabaikan semua bukti lainnya.
import numpy as np
# In log-space: log(0) = -inf destroys the sum
log_probs = [np.log(0.3), np.log(0.0), np.log(0.2), np.log(0.4)]
for word, lp in zip(['buy', 'bitcoin', 'now', 'cheap'], log_probs):
print(f'log P({word}|spam) = {lp}')
log_posterior_spam = sum(log_probs)
print(f'\nLog P(spam|doc) = {log_posterior_spam}') # -inf
print('Prediction is dominated by the single zero probability!')Penghalusan Laplace: Menambahkan Hitungan Semu
Penghalusan Laplace (juga disebut penghalusan aditif atau penghalusan tambah satu) menyelesaikan masalah probabilitas nol dengan menambahkan konstanta kecil alpha ke hitungan setiap kata sebelum menghitung probabilitas. Rumusnya menjadi: P(word | class) = (count(word, class) + alpha) / (total_words_in_class + alpha * vocab_size). Dengan alpha=1, setiap kata memperoleh setidaknya satu kemunculan 'virtual' di setiap kelas. Ini menjamin bahwa tidak ada kata yang memiliki probabilitas nol, sekaligus hanya memberi dampak minimal pada kata-kata yang memang sering muncul dalam data pelatihan.
import numpy as np
def laplace_prob(count_word_class, total_words_class, vocab_size, alpha=1.0):
return (count_word_class + alpha) / (total_words_class + alpha * vocab_size)
# Parameters
total_spam_words = 1000
vocab_size = 5000
alpha = 1.0
# Word seen 50 times in spam
P_buy_spam = laplace_prob(50, total_spam_words, vocab_size, alpha)
print(f'P(buy|spam) = {P_buy_spam:.6f}') # High probability
# Word NEVER seen in spam (count=0)
P_bitcoin_spam = laplace_prob(0, total_spam_words, vocab_size, alpha)
print(f'P(bitcoin|spam) = {P_bitcoin_spam:.6f}') # Small but non-zero
print('Zero-probability problem solved!')Dampak Alpha terhadap Probabilitas
Parameter alpha mengontrol seberapa besar penghalusan diterapkan. Alpha=1 (Laplace) menambahkan satu hitungan virtual untuk setiap kata di setiap kelas. Nilai alpha yang lebih besar menghasilkan penghalusan yang lebih kuat—probabilitas kata bergerak mendekati distribusi seragam (1/vocab_size). Nilai alpha yang sangat kecil (0,001) memberikan penghalusan minimal tetapi tetap stabil secara numerik. Alpha yang optimal menyeimbangkan penghapusan nilai nol dan pencegahan penghalusan berlebihan terhadap sinyal nyata. Validasi silang adalah cara yang tepat secara prinsip untuk memilih alpha—biasanya nilainya berada antara 0,01 dan 1,0 untuk sebagian besar tugas klasifikasi teks.
import numpy as np
total_words = 1000
vocab_size = 5000
count_buy = 50 # Seen 50 times
count_new = 0 # Never seen
print('Alpha comparison for two words:')
print(f'{"alpha":>8} | {"P(buy|class)":>15} | {"P(unseen|class)":>18}')
print('-' * 50)
for alpha in [0.001, 0.01, 0.1, 1.0, 10.0]:
p_buy = (count_buy + alpha) / (total_words + alpha * vocab_size)
p_new = (count_new + alpha) / (total_words + alpha * vocab_size)
print(f'{alpha:>8.3f} | {p_buy:>15.6f} | {p_new:>18.6f}')Penghalusan Lidstone: Generalisasi
Penghalusan Lidstone adalah bentuk umum penghalusan Laplace, dengan alpha yang dapat berupa nilai positif apa pun, bukan khusus 1,0. Jika alpha=1, metode ini disebut penghalusan Laplace (tambah satu). Jika alpha < 1, metode ini terkadang disebut penghalusan Jeffreys-Perks. Tidak ada nilai alpha yang terbaik secara universal—nilainya bergantung pada ukuran kosakata, ukuran data pelatihan, dan karakteristik data pengujian. Untuk set pelatihan besar (jutaan dokumen), nilai alpha yang sangat kecil (0,001) bekerja dengan baik karena sebagian besar kata telah terlihat. Untuk set pelatihan kecil, nilai alpha yang lebih besar mencegah penyesuaian berlebihan terhadap hitungan kata yang diamati.
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.pipeline import Pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import fetch_20newsgroups
train = fetch_20newsgroups(subset='train',
categories=['sci.space', 'rec.sport.hockey'],
remove=('headers', 'footers', 'quotes'))
pipe = Pipeline([
('vec', CountVectorizer(stop_words='english')),
('nb', MultinomialNB())
])
# GridSearch over alpha (Lidstone smoothing parameter)
grid = GridSearchCV(pipe, {'nb__alpha': [0.001, 0.01, 0.1, 0.5, 1.0, 5.0]},
cv=5)
grid.fit(train.data, train.target)
print('Best alpha:', grid.best_params_['nb__alpha'])
print('Best CV accuracy:', grid.best_score_.round(4))Mendemonstrasikan Perbaikan: Sebelum dan Sesudah Penghalusan
Berikut perbandingan konkret yang menunjukkan cara penghalusan mencegah bencana probabilitas nol. Tanpa penghalusan, dokumen yang berisi satu kata yang belum pernah terlihat memperoleh probabilitas posterior 0 untuk kelas yang terdampak. Dengan penghalusan, kata yang belum pernah terlihat tersebut menerima probabilitas kecil tetapi positif, sehingga kontribusi semua fitur lainnya tetap terjaga. Kelas yang diprediksi tidak berubah ketika kata yang belum pernah terlihat tidak bersifat diskriminatif, tetapi probabilitasnya kini menjadi angka yang bermakna, bukan 0 atau negatif tak terhingga.
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
import numpy as np
train_texts = ['buy cheap now offer deal', 'hello friend meeting lunch',
'discount click buy fast', 'project status update report']
train_labels = [1, 0, 1, 0]
vec = CountVectorizer()
X_train = vec.fit_transform(train_texts)
test_text = ['buy bitcoin now'] # 'bitcoin' unseen in training
X_test = vec.transform(test_text)
for alpha in [0.0, 1e-10, 1.0]:
nb = MultinomialNB(alpha=alpha if alpha > 0 else 1e-300)
nb.fit(X_train, train_labels)
prob = nb.predict_proba(X_test)
print(f'alpha={alpha}: P(ham)={prob[0][0]:.4f}, P(spam)={prob[0][1]:.4f}')Penghalusan dalam Praktik: Penanganan Kosakata
Penghalusan juga membantu menangani kata di luar kosakata (OOV) pada waktu inferensi. Kata-kata yang tidak ada dalam kosakata pelatihan akan diabaikan oleh CountVectorizer secara bawaan (kata-kata tersebut tidak memperoleh kolom dalam matriks fitur). Namun, kata-kata yang ada dalam kosakata tetapi memiliki hitungan nol pada salah satu kelas akan ditangani oleh penghalusan. Kedua mekanisme ini bekerja bersama: handle_unknown='ignore' milik CountVectorizer (untuk kata yang sama sekali belum terlihat) ditambah alpha milik MultinomialNB (untuk kata dengan hitungan nol di dalam kosakata). Alur teks yang tangguh menggunakan keduanya untuk menangani pergeseran kosakata yang tidak terhindarkan antara data pelatihan dan data penerapan.
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
import numpy as np
train_texts = ['cat dog bird', 'fish tank water', 'dog cat pet']
train_labels = [0, 1, 0]
vec = CountVectorizer()
X_train = vec.fit_transform(train_texts)
print('Training vocabulary:', list(vec.vocabulary_.keys()))
# Test with fully unseen word 'elephant'
test = ['cat dog elephant'] # 'elephant' not in vocabulary
X_test = vec.transform(test)
print('OOV word silently ignored, only cat+dog encoded')
nb = MultinomialNB(alpha=1.0)
nb.fit(X_train, train_labels)
print('Prediction:', nb.predict(X_test))Penghalusan untuk Varian Naive Bayes Lainnya
BernoulliNB menerapkan penghalusan Laplace dengan cara yang serupa: alih-alih probabilitas hitungan kata, metode ini menghaluskan probabilitas kehadiran biner P(feature=1|class) dan P(feature=0|class). GaussianNB menggunakan pendekatan berbeda—metode ini menambahkan sebagian kecil varians untuk menghindari varians nol pada fitur konstan: var_smoothing menambahkan sebagian dari varians terbesar dalam kumpulan data ke semua varians. Setiap varian memiliki mekanisme penghalusan yang sesuai dengan asumsi distribusinya, tetapi semuanya memiliki tujuan dasar yang sama: mencegah probabilitas nol yang dapat menyebabkan model gagal.
from sklearn.naive_bayes import BernoulliNB, GaussianNB
import numpy as np
# BernoulliNB with alpha smoothing (same as MultinomialNB)
bnb = BernoulliNB(alpha=1.0)
# GaussianNB with var_smoothing to prevent zero variance
gnb = GaussianNB(var_smoothing=1e-9) # Default: 1e-9 of max variance
print('BernoulliNB smooths P(feature=1|class) with alpha')
print('GaussianNB smooths variance with var_smoothing')
print('Both prevent zero probabilities in their respective distributions')
# var_smoothing default prevents failure on constant features
import numpy as np
X = np.array([[1,1],[2,2],[3,3],[1,2]])
y = np.array([0,0,1,1])
gnb.fit(X, y)
print('GaussianNB trained successfully even with near-constant features')Hubungan dengan Regularisasi pada Model Lain
Penghalusan Laplace dalam Naive Bayes secara konseptual mirip dengan regularisasi L2 dalam regresi logistik atau peluruhan bobot dalam jaringan saraf. Ketiga mekanisme tersebut mencegah nilai parameter yang ekstrem dengan menarik perkiraan menuju garis dasar yang netral (distribusi seragam untuk Laplace, bobot nol untuk L2). Perbedaan utamanya: penghalusan Laplace menargetkan perkiraan probabilitas dan memiliki interpretasi Bayesian yang jelas—setara dengan menambahkan alpha pengamatan imajiner untuk setiap kata ke setiap kelas. Alpha yang lebih besar berarti keyakinan awal yang lebih kuat bahwa semua kata memiliki kemungkinan yang sama, sehingga perkiraan menyusut menuju keseragaman.
# Bayesian interpretation of Laplace smoothing:
# Laplace smoothing = Dirichlet prior on word probabilities
# alpha=1 = uniform Dirichlet prior (all words equally likely before data)
# alpha -> 0 = no prior (maximum likelihood, prone to zero probs)
# alpha -> inf = strong prior (all words equally likely, ignores data)
import numpy as np
alphas = [0.001, 0.1, 1.0, 10.0, 100.0]
for alpha in alphas:
# Word counts: 'buy' seen 10x, 'rocket' seen 0x in spam (1000 words, 5000 vocab)
p_buy = (10 + alpha) / (1000 + alpha * 5000)
p_rocket = (0 + alpha) / (1000 + alpha * 5000)
ratio = p_buy / p_rocket
print(f'alpha={alpha:6.3f}: P(buy)/P(unseen) = {ratio:.1f}x')Menguji Penghalusan dalam Skenario Dunia Nyata
Untuk menunjukkan manfaat penghalusan secara meyakinkan, bandingkan model dengan dan tanpa penghalusan pada kumpulan data yang beberapa kata pengujiannya benar-benar tidak ada dalam data pelatihan. Buat kondisi ini secara artifisial dengan melatih model pada korpus kecil dan mengujinya pada korpus yang lebih besar. Tanpa penghalusan, akurasi merosot tajam karena kata di luar kosakata untuk kelas tertentu menyebabkan posterior bernilai nol. Dengan penghalusan, model menangani kata-kata baru dengan baik dan berfokus pada kata-kata yang dikenalnya. Ketangguhan inilah yang membuat Naive Bayes dengan penghalusan tetap menjadi garis dasar yang kuat, bahkan puluhan tahun setelah diperkenalkan.
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.datasets import fetch_20newsgroups
from sklearn.metrics import accuracy_score
train = fetch_20newsgroups(subset='train',
categories=['sci.space', 'rec.sport.hockey'],
remove=('headers','footers','quotes'))
test = fetch_20newsgroups(subset='test',
categories=['sci.space', 'rec.sport.hockey'],
remove=('headers','footers','quotes'))
vec = CountVectorizer(stop_words='english')
X_tr = vec.fit_transform(train.data)
X_te = vec.transform(test.data)
for alpha in [1e-10, 0.01, 0.1, 1.0]:
nb = MultinomialNB(alpha=alpha)
nb.fit(X_tr, train.target)
acc = accuracy_score(test.target, nb.predict(X_te))
print(f'alpha={alpha}: test accuracy = {acc:.4f}')Kesetaraan Penghalusan dengan Prior Dirichlet
Dari perspektif Bayesian, penghalusan Laplace setara dengan menerapkan prior Dirichlet simetris pada distribusi probabilitas kata untuk setiap kelas. Distribusi Dirichlet merupakan prior konjugat untuk distribusi multinomial, yang berarti posterior (berdasarkan hitungan kata yang diamati) juga berupa Dirichlet, dan perkiraan MAP (maksimum a posteriori) persis sama dengan rumus probabilitas yang dihaluskan dengan Laplace. Alpha adalah parameter konsentrasi prior Dirichlet: alpha=1 bersifat seragam (semua kata memiliki probabilitas awal yang sama); alpha<1 bersifat jarang (sebagian besar kata memiliki probabilitas awal yang mendekati nol); alpha>1 bersifat padat (mendorong semua kata menuju probabilitas yang sama). Kerangka Bayesian ini menjelaskan mengapa alpha kecil sesuai untuk korpus besar dan alpha besar untuk korpus kecil.
import numpy as np
# Dirichlet-Multinomial MAP estimate = Laplace smoothing
# P(word_i | class) = (count_i + alpha) / (N + V * alpha)
# where V = vocabulary size, N = total words seen in class
# For large corpus:
N_large = 1_000_000 # 1 million words in class
V = 50_000 # 50k vocabulary
count_unseen = 0
for alpha in [0.001, 0.01, 0.1, 1.0]:
p_unseen = (count_unseen + alpha) / (N_large + V * alpha)
print(f'alpha={alpha:.3f}: P(unseen|class) = {p_unseen:.2e}')
# Very small alpha keeps unseen words near-zero (good for large corpus)
# Large alpha smoothes too aggressively, inflates unseen word probsPemeriksaan Singkat
Uji pemahaman Anda tentang konsep Pembelajaran Mesin dengan Python dari pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini Anda telah mempelajari: masalah probabilitas nol muncul ketika kata-kata yang belum pernah dilihat menyebabkan seluruh probabilitas posterior runtuh menjadi nol, penghalusan Laplace menambahkan pseudohitungan alfa untuk menjamin setiap kata memiliki probabilitas positif, dan alfa optimal adalah hiperparameter yang disetel melalui validasi silang untuk menyeimbangkan penghapusan nilai nol tanpa terlalu menghaluskan sinyal nyata. Selanjutnya kita akan membahas metrik klasifikasi, termasuk akurasi, presisi, cakupan, dan skor F1.
Belajar Python dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Penghalusan Laplace dan Masalah Probabilitas Nol” gratis?
Ya — teks lengkap “Penghalusan Laplace dan Masalah Probabilitas Nol” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Machine Learning Academy, upgrade ke CoddyKit PRO. Kursus Machine Learning Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Penghalusan Laplace dan Masalah Probabilitas Nol”?
Peserta didik akan mengulangi kegagalan probabilitas nol pada kata yang belum pernah dilihat dan melihat cara penghalusan Laplace mencegah model memberikan probabilitas nol. Kamu berlatih Machine Learning Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Machine Learning Academy?
Tidak diperlukan pengalaman sebelumnya. Machine Learning Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Penghalusan Laplace dan Masalah Probabilitas Nol” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Teorema Bayes dalam Bahasa Sederhana
- Bag of Words: CountVectorizer dan TfidfVectorizer
- Melatih Pengklasifikasi Multinomial Naive Bayes
- Penghalusan Laplace dan Masalah Probabilitas Nol