Aturan Probabilitas

Probabilitas mengukur seberapa mungkin suatu kejadian terjadi, sedangkan aturan probabilitas menyediakan cara menghitungnya secara sistematis tanpa menebak. Topik ini membahas ruang sampel dan kejadian, aturan komplemen, aturan penjumlahan dan perkalian, serta probabilitas bersyarat, lengkap dengan padanan operasi and, or, dan not pada percabangan kode. Setelah topik ini dipahami, peluang mata dadu genap apabila mata dadunya diketahui lebih dari tiga dapat dihitung dengan rumus dan sekaligus diverifikasi lewat simulasi NumPy.

Ruang sampel dan kejadian#

Setiap percobaan acak memiliki kumpulan hasil yang mungkin, disebut ruang sampel (sample space), dan ditulis $S$. Satu kali pelemparan dadu baku memiliki $S = \{1, 2, 3, 4, 5, 6\}$, sedangkan dua pelemparan memiliki 36 pasangan hasil. Kejadian (event) adalah subset dari ruang sampel, misalnya $A$ untuk mata dadu genap dan $B$ untuk mata dadu lebih dari 3.

Peluang kejadian $A$ pada ruang sampel berhingga dengan hasil yang sama mungkin didefinisikan sebagai perbandingan antara banyaknya anggota kejadian dan banyaknya anggota ruang sampel.

Definisi tersebut memenuhi dua batasan dasar probabilitas, yaitu $P(S) = 1$ dan $0 \le P(A) \le 1$. Karena kejadian adalah himpunan, ketiga operasi himpunan langsung membentuk kejadian baru, yaitu gabungan untuk “atau”, irisan untuk “dan”, serta komplemen untuk “tidak”. Pemetaan inilah yang membuat pernyataan peluang dapat diterjemahkan ke ekspresi boolean pada kode tanpa mengubah maknanya.

Aturan komplemen, penjumlahan, dan perkalian#

Aturan komplemen menghitung peluang kejadian $A^c$, yaitu kejadian bahwa $A$ tidak terjadi. Karena $A$ dan $A^c$ bersama-sama mencakup seluruh ruang sampel tanpa tumpang tindih, peluang keduanya selalu berjumlah satu.

Aturan penjumlahan menghitung peluang gabungan dua kejadian, dan diagram berikut memperlihatkan daerah yang dihitungnya.

Pengurangan $P(A \cap B)$ mencegah penghitungan ganda, karena daerah irisan ikut terhitung pada $P(A)$ maupun $P(B)$. Apabila dua kejadian saling lepas (mutually exclusive) sehingga irisannya kosong, suku terakhir hilang dan peluang gabungannya berupa penjumlahan biasa. Untuk kejadian yang saling bebas (independent), yaitu kejadian yang kemunculannya tidak saling memengaruhi, aturan perkalian berlaku.

Melempar dua dadu yang berbeda menghasilkan kejadian yang saling bebas, sehingga peluang keduanya genap sama dengan $\frac{1}{2} \times \frac{1}{2} = \frac{1}{4}$. Asumsi kemandirian inilah yang kelak digunakan oleh filter spam Naive Bayes pada topik Teorema Bayes.

Probabilitas bersyarat#

Probabilitas bersyarat (conditional probability) menghitung peluang $A$ dengan pengetahuan tambahan bahwa $B$ sudah terjadi, dan ditulis $P(A \mid B)$. Secara mekanis, ruang sampel menyempit menjadi $B$, sehingga yang dihitung hanyalah bagian $A$ yang berada di dalam $B$.

Pada contoh dadu, $P(A \cap B) = \frac{1}{3}$ karena irisannya adalah $\{4, 6\}$, sedangkan $P(B) = \frac{1}{2}$, sehingga $P(A \mid B) = \frac{2}{3}$. Pengetahuan bahwa mata dadu lebih dari 3 menaikkan peluang kemunculan angka genap dari $\frac{1}{2}$ menjadi $\frac{2}{3}$. Apabila nilai bersyarat tersebut persis sama dengan $P(A)$, pengetahuan tentang $B$ tidak memberi informasi apa pun, dan kedua kejadian disebut saling bebas. Kemandirian yang dinyatakan lewat rumus ini setara dengan definisi perkalian pada bagian sebelumnya.

Menghitung aturan probabilitas dengan Python#

Skrip berikut menghitung seluruh aturan pada bagian sebelumnya untuk contoh dadu. Tipe Fraction dipilih agar pecahan dihitung secara eksak, sehingga hasil seperti $\frac{2}{3}$ tidak kehilangan presisi karena pembulatan float.

"""Aturan komplemen, penjumlahan, perkalian, dan probabilitas bersyarat."""
from fractions import Fraction

S = list(range(1, 7))                # ruang sampel satu dadu: {1, 2, 3, 4, 5, 6}
A = [x for x in S if x % 2 == 0]     # A: mata dadu genap
B = [x for x in S if x > 3]          # B: mata dadu lebih dari 3

def P(kejadian):
    return Fraction(len(kejadian), len(S))

irisan = [x for x in S if x in A and x in B]
print("P(A)          =", P(A), "=", float(P(A)))
print("P(B)          =", P(B), "=", float(P(B)))
print("P(komplemen A)=", 1 - P(A))
print("P(A irisan B) =", P(irisan))
print("P(A gabung B) =", P(A) + P(B) - P(irisan))
print("P(A | B)      =", P(irisan) / P(B))
print("P(A) * P(B)   =", P(A) * P(B), "-> bebas:", P(irisan) == P(A) * P(B))

P(A)          = 1/2 = 0.5
P(B)          = 1/2 = 0.5
P(komplemen A)= 1/2
P(A irisan B) = 1/3
P(A gabung B) = 2/3
P(A | B)      = 2/3
P(A) * P(B)   = 1/4 -> bebas: False

Baris terakhir menegaskan bahwa $A$ dan $B$ tidak saling bebas, karena $P(A \cap B) = \frac{1}{3}$, sedangkan $P(A) \times P(B) = \frac{1}{4}$. Nilai eksak pada keluaran memudahkan pemeriksaan rumus, tetapi percobaan nyata sering hanya menyediakan data, bukan ruang sampel yang rapi. Simulasi Monte Carlo memverifikasi rumus yang sama dari sisi frekuensi, dan benih tetap membuat keluarannya dapat direproduksi.

import numpy as np

rng = np.random.default_rng(42)
lemparan = rng.integers(1, 7, size=100_000)   # 100.000 pelemparan dadu
A = lemparan % 2 == 0                         # mata dadu genap
B = lemparan > 3                              # mata dadu lebih dari 3
print("estimasi P(A)          :", np.round(A.mean(), 4))
print("estimasi P(B)          :", np.round(B.mean(), 4))
print("estimasi P(A gabung B) :", np.round((A | B).mean(), 4))
print("estimasi P(A irisan B) :", np.round((A & B).mean(), 4))
print("estimasi P(A | B)      :", np.round(A[B].mean(), 4))

estimasi P(A)          : 0.4996
estimasi P(B)          : 0.5009
estimasi P(A gabung B) : 0.6678
estimasi P(A irisan B) : 0.3328
estimasi P(A | B)      : 0.6643

Kelima estimasi berada dekat dengan nilai eksak $\frac{1}{2}$, $\frac{2}{3}$, dan $\frac{1}{3}$, dan kesesuaiannya makin rapat apabila jumlah percobaan diperbesar. Perilaku ini adalah hukum bilangan besar dalam bentuk paling sederhana. Operasi |, &, dan perbandingan array pada blok tersebut juga memetakan gabungan, irisan, serta kejadian ke data secara langsung, sehingga rumus dan kode menggunakan notasi yang sama.

Di mana hal ini ditemui dalam kode#

Setiap kondisi if pada kode adalah kejadian, dan operator and, or, not bertindak sebagai irisan, gabungan, serta komplemen kejadiannya. Penilaian kondisi bekerja secara short-circuit, yaitu Python berhenti menilai sisa ekspresi begitu keputusannya sudah pasti. Sifat ini berguna untuk menyaring pesan berdasarkan pola kata, sebagaimana ditunjukkan percabangan berikut.

teks = "menang hadiah gratis klik sekarang"
gratis = "gratis" in teks
menang = "menang" in teks
jadwal = "jadwal" in teks

print("kata 'gratis'     :", gratis)
print("kata 'menang'     :", menang)
print("kata 'jadwal'     :", jadwal)
print("gratis and menang :", gratis and menang)
print("gratis or jadwal  :", gratis or jadwal)
print("not jadwal        :", not jadwal)

if (gratis or menang) and not jadwal:
    print("keputusan: pesan ditandai sebagai calon spam")
else:
    print("keputusan: pesan diloloskan sebagai pesan rutin")

kata 'gratis'     : True
kata 'menang'     : True
kata 'jadwal'     : False
gratis and menang : True
gratis or jadwal  : True
not jadwal        : True
keputusan: pesan ditandai sebagai calon spam

Aturan probabilitas mengubah penyaring berbasis pola tersebut menjadi penyaring berbasis peluang. Dari korpus pesan yang sudah berlabel, setiap aturan menjadi pembagian hitungan sederhana, dan NumPy mengerjakannya pada array boolean.

import numpy as np

# korpus pesan kecil yang sudah berlabel: (teks, label spam)
korpus = [
    ("menang hadiah gratis klik sekarang", True),
    ("gratis undian hadiah menang", True),
    ("klik link gratis hadiah", True),
    ("gratis tempat parkir kantor", False),
    ("jadwal piket kantor minggu depan", False),
    ("notulen rapat kantor terlampir", False),
    ("jadwal rapat kantor hari senin", False),
    ("hasil rapat kantor bulan lalu", False),
]
spam = np.array([label for _, label in korpus])
kunci = np.array(["gratis" in teks or "menang" in teks for teks, _ in korpus])

print("jumlah pesan      :", len(korpus))
print("P(spam)           :", np.round(spam.mean(), 4))
print("P(kata kunci)     :", np.round(kunci.mean(), 4))
print("P(spam dan kunci) :", np.round((spam & kunci).mean(), 4))
print("P(spam | kunci)   :", np.round(spam[kunci].mean(), 4))

jumlah pesan      : 8
P(spam)           : 0.375
P(kata kunci)     : 0.5
P(spam dan kunci) : 0.375
P(spam | kunci)   : 0.75

Pada keluaran, peluang pesan spam adalah $0.375$, tetapi naik menjadi $0.75$ begitu kata kunci ditemukan. Kenaikan ini persis merupakan makna probabilitas bersyarat, yaitu bukti baru yang mempersempit ruang sampel. Pembalikan arah bersyarat, misalnya dari $P(\text{kata kunci} \mid \text{spam})$ menuju $P(\text{spam} \mid \text{kata kunci})$, dikerjakan oleh teorema Bayes yang dibahas pada topik tersendiri dalam modul ini.

Ringkasan#

• Kejadian adalah subset dari ruang sampel $S$, dengan peluang $P(A) = \frac{|A|}{|S|}$ pada ruang sampel berhingga yang hasilnya sama mungkin, serta batasan $0 \le P(A) \le 1$ dan $P(S) = 1$.
• Aturan komplemen $P(A^c) = 1 - P(A)$, aturan penjumlahan $P(A \cup B) = P(A) + P(B) - P(A \cap B)$, dan aturan perkalian $P(A \cap B) = P(A) \times P(B)$ untuk kejadian saling bebas.
• Probabilitas bersyarat $P(A \mid B) = \frac{P(A \cap B)}{P(B)}$ mempersempit ruang sampel ke $B$, dan kejadian saling bebas dicirikan oleh $P(A \mid B) = P(A)$.
• Operator and, or, dan not pada percabangan memetakan irisan, gabungan, dan komplemen kejadian, sedangkan array NumPy menggunakan & dan | untuk kejadian yang disimpan sebagai boolean.

Referensi#

• Introductory Statistics — OpenStax — Buku teks terbuka yang membahas probabilitas dasar beserta aturan komplemen, penjumlahan, perkalian, dan probabilitas bersyarat.
• numpy.random.Generator — NumPy Developers — Dokumentasi generator acak NumPy yang menyediakan fungsi integers untuk simulasi Monte Carlo pada topik ini.
• fractions — Python Software Foundation — Dokumentasi tipe Fraction yang digunakan skrip contoh untuk menghitung pecahan secara eksak.