Machine Learning Academy · leksjon

Bayes' teorem forklart enkelt

De vil arbeide med et konkret eksempel fra medisinske tester for å utvikle en intuitiv forståelse av a priori-sannsynlighet, sannsynlighet og posterior sannsynlighet uten omfattende matematikk.

Leksjon 1 av 413 trinn

Bayes' teorem forklart enkelt er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva er Bayes' teorem?

Bayes' teorem er en matematisk regel for å oppdatere antakelser i lys av nye bevis. Det besvarer spørsmålet: Gitt at jeg observerte X, hvor sannsynlig er hypotesen H? Formelen er: P(H|X) = P(X|H) * P(H) / P(X). Med enklere ord er den posteriore sannsynligheten for H gitt X lik sannsynligheten for å observere X dersom H er sann, multiplisert med den prioriterte sannsynligheten for H, delt på den samlede sannsynligheten for å observere X. Bayes' teorem er grunnleggende innen maskinlæring, statistikk og rasjonell resonnering under usikkerhet.

# Bayes' theorem components:
# P(H|X)  = Posterior  -- What we want to know
#                         'Probability of H given we observed X'
# P(X|H)  = Likelihood -- How likely is X if H is true?
# P(H)    = Prior      -- Our belief in H before seeing X
# P(X)    = Evidence   -- Overall probability of observing X

# Rearranged:
# Posterior = (Likelihood * Prior) / Evidence

print('Posterior = (Likelihood * Prior) / Evidence')

Et eksempel med en medisinsk test

La oss utvikle intuisjonen med et klassisk eksempel. En sjelden sykdom rammer 1 % av befolkningen. En test er 95 % nøyaktig: Hvis De har sykdommen, gir testen positivt resultat i 95 % av tilfellene; hvis De ikke har den, gir testen negativt resultat i 95 % av tilfellene (5 % andel falske positive). Hvis testen er positiv, hva er sannsynligheten for at De faktisk har sykdommen? De fleste får intuitivt 95 %, men Bayes' teorem viser at svaret er langt lavere – fordi sykdommen er så sjelden, er de fleste positive resultater faktisk falske positive.

# Medical test: Bayes' theorem applied
P_disease    = 0.01   # Prior: 1% have the disease
P_no_disease = 0.99   # 99% are healthy

P_pos_given_disease    = 0.95  # True positive rate (sensitivity)
P_pos_given_no_disease = 0.05  # False positive rate

# P(positive) = total probability of a positive test
P_positive = (P_pos_given_disease * P_disease +
              P_pos_given_no_disease * P_no_disease)

# Bayes: P(disease | positive)
P_disease_given_pos = (P_pos_given_disease * P_disease) / P_positive

print(f'P(disease | positive test) = {P_disease_given_pos:.2%}')
# Only ~16%! Not 95% -- the low prior dominates

Prior, sannsynlighet og posterior forklart

De tre viktigste begrepene i Bayes' teorem er: Prior P(H) er antakelsen Deres om H før De ser noen bevis – i det medisinske eksempelet er dette sykdommens forekomst på 1 %. Sannsynlighet P(X|H) er hvor godt beviset X forklares av hypotesen H – her den sanne positive raten på 95 %. Posterior P(H|X) er den oppdaterte antakelsen Deres etter at beviset er tatt med i beregningen. Posteriorsannsynligheten fra én observasjon blir prioren for den neste – Bayes' teorem beskriver en kontinuerlig læringsprosess der antakelser oppdateres etter hvert som bevis samler seg.

# Sequential Bayesian updating
# Start with 1% prior, observe 3 positive tests

prior = 0.01
P_pos_given_disease = 0.95
P_pos_given_no_disease = 0.05

for test_num in range(1, 4):
    likelihood_pos = P_pos_given_disease
    P_positive = likelihood_pos * prior + P_pos_given_no_disease * (1 - prior)
    posterior = (likelihood_pos * prior) / P_positive
    
    print(f'After test {test_num}: P(disease) = {posterior:.3%}')
    prior = posterior  # Posterior becomes new prior

# Three positive tests raise probability substantially

Bayes' teorem for klassifisering

I maskinlæringsbasert klassifisering gir Bayes' teorem oss sannsynligheten for hver klasse gitt de observerte egenskapene: P(class | features) ∝ P(features | class) * P(class). Vi predikerer klassen med høyest posteriorsannsynlighet. P(class) estimeres ut fra klassefrekvenser i treningsdataene (prior). P(features | class) estimeres ut fra fordelingen av egenskapene innenfor hver klasse (sannsynlighet). Naive Bayes forenkler beregningen av sannsynligheten ved å anta at egenskapene er uavhengige gitt klassen – en «naiv» antakelse som ofte fungerer overraskende godt i praksis.

# Classification with Bayes' theorem
# Predict P(spam | email_features) vs P(ham | email_features)

# Prior (from training data)
P_spam = 0.3  # 30% of emails are spam
P_ham  = 0.7  # 70% are ham

# Likelihood: P(features | class) from training
# (simplified: single word 'offer' seen)
P_offer_given_spam = 0.6  # 'offer' appears in 60% of spam
P_offer_given_ham  = 0.1  # 'offer' appears in 10% of ham

# Unnormalised posteriors (ignore P(offer) -- same denominator)
posterior_spam = P_offer_given_spam * P_spam  # 0.18
posterior_ham  = P_offer_given_ham  * P_ham   # 0.07

print('Unnormalised: spam=', posterior_spam, 'ham=', posterior_ham)
print('Predicted class: spam' if posterior_spam > posterior_ham else 'ham')

Loven om total sannsynlighet

Nevneren i Bayes' teorem, P(X), beregnes ofte ved hjelp av loven om total sannsynlighet: P(X) = sum over all classes c of P(X|c) * P(c). Dette sikrer at posteriorsannsynlighetene for alle klasser summerer seg til 1. I det medisinske eksempelet er P(positiv) = P(positiv|sykdom)*P(sykdom) + P(positiv|ingen sykdom)*P(ingen sykdom). I Naive Bayes-klassifisering hopper vi vanligvis over beregningen av P(X) fordi den er den samme for alle klasser – vi sammenligner bare de unormaliserte posteriorene for å finne den mest sannsynlige klassen.

# Law of total probability: P(X) = sum_c P(X|c) * P(c)
classes  = ['spam', 'ham', 'newsletter']
priors   = [0.3,    0.5,   0.2]          # Must sum to 1.0
P_word_given_class = [0.5, 0.1, 0.3]     # Likelihood of 'free' in each class

# Total probability of seeing the word 'free'
P_free = sum(lik * pri for lik, pri in zip(P_word_given_class, priors))
print(f'P(free) = {P_free}')

# Posteriors (normalised)
for cls, pri, lik in zip(classes, priors, P_word_given_class):
    posterior = lik * pri / P_free
    print(f'P({cls} | free) = {posterior:.3f}')

Fra formel til algoritme

Bayes' teorem kan oversettes direkte til en klassifiseringsalgoritme. Gitt et merket treningssett: Trinn 1: estimer P(class) for hver klasse ut fra klassefrekvensene. Trinn 2: estimer P(feature | class) for hver kombinasjon av egenskap og klasse. Trinn 3: beregn P(class | features) ∝ P(features | class) * P(class) for hver klasse for en ny prøve. Trinn 4: prediker klassen med høyest posterior. Den «naive» tilnærmingen i Naive Bayes forenkler trinn 2: anta at P(features|class) = produktet av P(feature_i | class) for alle egenskaper.

# Naive Bayes algorithm in pseudocode

# Training:
# For each class c:
#   prior[c] = count(class==c) / total_samples
#   For each feature f:
#     likelihood[c][f] = P(feature_f | class==c)  # from training data

# Prediction for new sample x:
# For each class c:
#   log_prob[c] = log(prior[c])
#   For each feature f:
#     log_prob[c] += log(likelihood[c][f=x_f])  # naive: assume independence
# return argmax(log_prob)  # class with highest log-posterior

print('Naive independence assumption: P(f1,f2,...|c) = P(f1|c)*P(f2|c)*...*P(fn|c)')

Hvorfor logaritmiske sannsynligheter unngår underflyt

Når mange små sannsynligheter multipliseres med hverandre, underflyter resultatet raskt til 0 i flyttallsaritmetikk – selv om verdien matematisk sett er et svært lite tall som ikke er lik 0. Et dokument med 100 ord, der hvert ord har P(word|class)=0.01, gir for eksempel 0.01^100 = 10^{-200}, som er mindre enn den minste float64-verdien. Beregning i logaritmeringsrom gjør multiplikasjon om til addisjon: log(a*b) = log(a) + log(b). Siden vi sammenligner logaritmiske posteriorer, ikke de faktiske posteriorene, blir argmax-avgjørelsen identisk. Implementasjoner av Naive Bayes arbeider alltid i logaritmeringsrom for å sikre numerisk stabilitet.

import numpy as np

# Direct multiplication: underflows
probs = [0.1] * 100  # 100 features, each P=0.1
product = np.prod(probs)
print('Direct product:', product)  # 0.0 -- underflow!

# Log space: numerically stable
log_sum = np.sum(np.log(probs))
print('Log sum:', log_sum)         # -100 * log(10) -- valid

# Compare two classes
log_prob_A = np.sum(np.log([0.1] * 100))
log_prob_B = np.sum(np.log([0.2] * 100))
print('Class A log-prob:', log_prob_A)
print('Class B log-prob:', log_prob_B)
print('Predicted:', 'A' if log_prob_A > log_prob_B else 'B')

Bayes-optimal klassifikator: gullstandarden

Den Bayes-optimale klassifikatoren er den teoretisk best mulige klassifikatoren for en gitt datafordeling. Den predikerer klassen med høyest sann, posterior sannsynlighet P(class|features). Ingen annen klassifikator kan oppnå en lavere forventet feilrate på denne fordelingen. I praksis kan vi ikke bruke den Bayes-optimale klassifikatoren fordi vi ikke kjenner de sanne fordelingene – vi kan bare estimere dem fra et begrenset datagrunnlag. Naive Bayes er en tilnærming til den Bayes-optimale klassifikatoren under antakelsen om uavhengighet. Når denne antakelsen holder, er Naive Bayes den optimale klassifikatoren.

# The Bayes error rate is the irreducible error
# Even a perfect model cannot beat it on a given distribution

# Example: predicting coin flip from noisy signal
import numpy as np

np.random.seed(42)
# True label: 50/50 coin
y_true = np.random.choice([0, 1], size=1000)
# Signal: 70% correlated with true label
signal = np.where(np.random.rand(1000) < 0.7, y_true, 1-y_true)

# Optimal prediction: just use the signal
acc = (signal == y_true).mean()
print(f'Optimal classifier accuracy: {acc:.3f}')
print(f'Bayes error rate (irreducible): {1-0.70:.3f} = 30%')

Praktiske bruksområder for Bayes' teorem

Bayes' teorem er ikke bare en formel fra undervisningen – det driver mange systemer i den virkelige verden. E-postfiltre for søppelpost beregner P(spam | ord) ut fra ordfrekvenser i kjent søppelpost og legitim e-post. Systemer for medisinsk diagnostikk oppdaterer sannsynlighetene for sykdommer etter hvert som testresultater kommer inn. Søkemotorer bruker Bayesiansk rangering til å kombinere relevans for søket med dokumentets popularitet. Autonome kjøretøy bruker Bayesiansk filtrering (Kalman-filter, partikkelfilter) til å spore posisjonen sin basert på støyende sensoravlesninger. A/B-testing i næringslivet bruker i økende grad Bayesianske rammeverk som gir sannsynligheten for å være best, i stedet for p-verdier.

# Real-world Bayes: A/B test - which version is better?
# After 100 conversions from 1000 visitors for version A
# and 120 conversions from 1000 visitors for version B:

from scipy import stats

# Beta distribution as posterior for conversion rate
alpha_A, beta_A = 100 + 1, 900 + 1  # Beta(successes+1, failures+1)
alpha_B, beta_B = 120 + 1, 880 + 1

# Monte Carlo: P(B is better than A)
samples_A = stats.beta(alpha_A, beta_A).rvs(100000)
samples_B = stats.beta(alpha_B, beta_B).rvs(100000)

P_B_better = (samples_B > samples_A).mean()
print(f'P(B is better than A): {P_B_better:.3f}')

Uavhengighetsantakelsen: Når er den gyldig?

Den «naive» delen av Naive Bayes antar at egenskapene er kondisjonelt uavhengige gitt klassen. For tekstdata betyr dette at hvert ords forekomst antas å være uavhengig av andre ord, gitt klassen. I virkeligheten opptrer ord som «kreditt» og «kort» sammen – de er korrelerte. Empiriske studier viser likevel at Naive Bayes fungerer godt selv når uavhengighetsantakelsen brytes, fordi: (1) rangering for klassifisering bare krever riktig rekkefølge på posteriorene, ikke nøyaktige sannsynligheter; (2) mange egenskaper gjør at uavhengige signaler kombineres godt; (3) enkelheten hindrer overtilpasning på små datasett.

# When does naive independence work?
# Even with correlated features, naive bayes often ranks classes correctly

import numpy as np

# Two correlated features that both indicate spam
words = {'buy': 0, 'now': 1, 'click': 2, 'here': 3}

# Spam email often has all four; ham rarely does
# Independence assumption ignores that 'buy' and 'now' co-occur
# But the combined signal is still strong for detecting spam

P_word_spam = [0.7, 0.6, 0.5, 0.6]
P_word_ham  = [0.1, 0.1, 0.05, 0.1]

# For email with all 4 words
log_spam = np.sum(np.log(P_word_spam))
log_ham  = np.sum(np.log(P_word_ham))
print('Log P(features|spam):', log_spam.round(2))
print('Log P(features|ham): ', log_ham.round(2))
print('Predicted: SPAM' if log_spam > log_ham else 'HAM')

Bayes-faktor: Sammenligning av hypoteser

Bayes-faktoren er forholdet mellom likelihood-verdiene for to konkurrerende hypoteser: BF = P(evidence | H1) / P(evidence | H0). I motsetning til p-verdier, som bare forteller om nullhypotesen skal forkastes, kvantifiserer Bayes-faktoren hvor mye evidensen taler for én hypotese fremfor en annen. BF > 10 er sterk evidens for H1, BF < 0.1 er sterk evidens for H0, og verdier mellom 1/3 og 3 er ikke konklusive. Bayes-faktorer brukes stadig mer innen forskning og industri til A/B-testing og hypotes evaluering fordi de naturlig inkorporerer forhåndsinformasjon og gir en tolkbar styrke på evidensen.

# Bayes Factor example: comparing two models
# H0: coin is fair (p=0.5)
# H1: coin is biased (p=0.7)
# Observed: 8 heads in 10 flips

from scipy.stats import binom

observed_heads = 8
n_flips = 10

# Likelihood under each hypothesis
L_H0 = binom.pmf(observed_heads, n_flips, p=0.5)
L_H1 = binom.pmf(observed_heads, n_flips, p=0.7)

BF = L_H1 / L_H0
print(f'P(8 heads | fair coin) = {L_H0:.4f}')
print(f'P(8 heads | p=0.7)    = {L_H1:.4f}')
print(f'Bayes Factor (H1/H0)  = {BF:.2f}')
print('BF > 3: moderate evidence for biased coin')

Hurtigsjekk

Test forståelsen Deres av konsepter innen Machine Learning med Python fra denne leksjonen.

Oppsummering av leksjonen

I denne leksjonen lærte De at: Bayes' teorem oppdaterer forhåndsoppfatninger med evidens for å gi etterfølgende oppfatninger, om de tre komponentene (prior, likelihood, posterior) og hvordan de samhandler, samt hvorfor lave forhåndssannsynligheter kan dominere selv tester med høy nøyaktighet (som i eksempelet med medisinsk diagnose). Neste gang utforsker vi Bag of Words med CountVectorizer og TfidfVectorizer for å konvertere tekst til tall for Naive Bayes-klassifisering.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
30
Leksjoner
120

Ofte stilte spørsmål

Er leksjonen «Bayes' teorem forklart enkelt» gratis?

Ja – hele teksten i «Bayes' teorem forklart enkelt» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Bayes' teorem forklart enkelt»?

De vil arbeide med et konkret eksempel fra medisinske tester for å utvikle en intuitiv forståelse av a priori-sannsynlighet, sannsynlighet og posterior sannsynlighet uten omfattende matematikk. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Machine Learning Academy?

Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Bayes' teorem forklart enkelt»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?

Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Bayes' teorem forklart enkelt
  2. Bag-of-words: CountVectorizer og TfidfVectorizer
  3. Trene en multinomisk Naive Bayes-klassifikator
  4. Laplace-utglatting og problemet med nullsannsynlighet
← Tilbake til Machine Learning Academy