Ragionare sotto incertezza: perché un test positivo non basta
Un test medico con il 90% di sensibilità e il 5% di falsi positivi risulta positivo: quanto è probabile che tu sia malato? Se la malattia colpisce una persona su cento, la risposta è circa il 15%, non il 90%. Questo errore di intuizione è lo stesso che fa sovrastimare un classificatore con alta accuratezza su una classe rara, e si corregge con un solo strumento, il teorema di Bayes. L'articolo lo costruisce a partire dalla probabilità condizionata, passa alle distribuzioni che servono davvero nel machine learning, mostra che addestrare un modello è stimare parametri (massima verosimiglianza, poi massima a posteriori) e chiude con il test d'ipotesi, l'altro modo di decidere se un effetto è reale. Ogni formula ha un conto a mano e una verifica in codice.
Nella notazione della serie, P(\cdot) è la probabilità, \mathbb{E}[\cdot] il valore atteso e \theta i parametri del modello, come nell'articolo sull'algebra lineare; i dati osservati sono D. La derivata del logaritmo della verosimiglianza userà quanto visto nell'articolo sul calcolo differenziale.
Probabilità condizionata, indipendenza e teorema di Bayes
La probabilità di A sapendo che B è avvenuto è P(A \mid B) = P(A \cap B)/P(B): si restringe l'universo ai soli casi in cui B è vero. Due eventi sono indipendenti se sapere B non cambia P(A), cioè P(A \cap B) = P(A)P(B). Scambiando i ruoli di A e B nella definizione si ricava il teorema di Bayes, che inverte il condizionamento: da «quanto è probabile il dato se l'ipotesi è vera» a «quanto è probabile l'ipotesi dato il dato».
Nel linguaggio dell'inferenza, le quattro quantità hanno nomi propri:
- P(\theta) è il prior, la credenza sull'ipotesi prima di vedere i dati
- P(D \mid \theta) è la verosimiglianza (likelihood), quanto i dati osservati sono plausibili se l'ipotesi è vera
- P(\theta \mid D) è il posterior, la credenza aggiornata dopo i dati
- P(D) è l'evidenza, una costante che rende il posterior una probabilità: si ottiene sommando P(D \mid \theta)P(\theta) su tutte le ipotesi
Le prime tre voci sono il cuore della formula: il posterior è proporzionale al prodotto di verosimiglianza e prior. L'evidenza non dipende dall'ipotesi, quindi per confrontare due ipotesi basta confrontare i numeratori; è ciò che si fa nella classificazione. Il prior è la voce che si dimentica, ed è quella che nel test medico decide il risultato.
Il conto. Con prevalenza P(M) = 0{,}01, sensibilità P(+ \mid M) = 0{,}90 e falsi positivi P(+ \mid \text{non } M) = 0{,}05, la probabilità totale di un risultato positivo è P(+) = 0{,}90 \cdot 0{,}01 + 0{,}05 \cdot 0{,}99 = 0{,}009 + 0{,}0495 = 0{,}0585. Quindi P(M \mid +) = 0{,}009/0{,}0585 \approx 0{,}1538. In altre parole, su mille persone solo 10 sono malate e 9 di loro risultano positive, ma anche 49,5 dei 990 sani lo sono: un positivo su sei è davvero malato.
import numpy as np
prev, sens, fpr = 0.01, 0.90, 0.05 # P(M), P(+|M), P(+|non M)
p_pos = sens * prev + fpr * (1 - prev) # P(+) per la legge della probabilita' totale
post = sens * prev / p_pos # Bayes: P(M|+)
print(f"P(+) = {p_pos:.4f} P(M|+) = {post:.4f}")
rng = np.random.default_rng(0)
n = 1_000_000
ill = rng.random(n) < prev
pos = np.where(ill, rng.random(n) < sens, rng.random(n) < fpr)
print(f"simulazione: {pos.sum()} positivi su {n}, di cui malati {np.mean(ill[pos]):.4f}")
for prev2 in (0.001, 0.01, 0.1, 0.5):
p2 = sens * prev2 + fpr * (1 - prev2)
print(f"prevalenza {prev2:5.3f} -> P(M|+) = {sens * prev2 / p2:.4f}")
# Output:
# P(+) = 0.0585 P(M|+) = 0.1538
# simulazione: 58261 positivi su 1000000, di cui malati 0.1539
# prevalenza 0.001 -> P(M|+) = 0.0177
# prevalenza 0.010 -> P(M|+) = 0.1538
# prevalenza 0.100 -> P(M|+) = 0.6667
# prevalenza 0.500 -> P(M|+) = 0.9474
Le prime due righe del listato ripetono il conto a mano. La simulazione genera un milione di persone, assegna a ciascuna la malattia e il risultato del test, e misura la frazione di malati fra i positivi: 0{,}1539, che coincide con 0{,}1538 a meno del rumore di campionamento. Il ciclo finale mostra l'effetto del prior: con prevalenza 0,1% lo stesso test dà un posterior di appena 1,8%, con prevalenza 50% sale al 94,7%. La stessa logica vale per un classificatore di frodi o di spam: la sua accuratezza non dice nulla sulla probabilità che un allarme sia vero finché non si specifica quanto è rara la classe.
Valore atteso, varianza e le distribuzioni che servono nel machine learning
Il valore atteso di una variabile aleatoria X è la media pesata dei suoi valori, \mathbb{E}[X] = \sum_x x\,P(X = x) (per variabili continue la somma diventa un integrale con la densità). La varianza misura la dispersione, \mathrm{Var}(X) = \mathbb{E}[(X - \mu)^2] = \mathbb{E}[X^2] - \mathbb{E}[X]^2, e la deviazione standard \sigma = \sqrt{\mathrm{Var}(X)} ha la stessa unità di X. Per un dado equo \mathbb{E}[X] = (1 + \dots + 6)/6 = 3{,}5 e \mathbb{E}[X^2] = 91/6, quindi \mathrm{Var}(X) = 91/6 - 3{,}5^2 = 35/12 \approx 2{,}9167.
Tre distribuzioni coprono la maggior parte dei casi pratici. La Bernoulli descrive un esito binario: P(X = k) = p^k(1-p)^{1-k} per k \in \{0, 1\}, con media p e varianza p(1-p); l'uscita di un neurone sigmoideo è il parametro p di una Bernoulli. La categorica la generalizza a K classi con probabilità p_1, \dots, p_K che sommano a 1; l'uscita di una softmax è una distribuzione categorica. La gaussiana ha densità
con media \mu e varianza \sigma^2. Per altezze con \mu = 170 cm e \sigma = 10 cm, circa il 68,3% della popolazione sta entro una deviazione standard (160–180 cm) e il 95,4% entro due (150–190 cm). La gaussiana compare ovunque grazie al teorema del limite centrale, trattato più avanti.
import numpy as np
from scipy import stats
faces = np.arange(1, 7)
mean = faces.mean() # E[X] = (1+...+6)/6
var = (faces ** 2).mean() - mean ** 2 # E[X^2] - E[X]^2
print(f"dado: E = {mean}, Var = {var:.4f} (35/12 = {35 / 12:.4f})")
rng = np.random.default_rng(1)
rolls = rng.integers(1, 7, size=100_000)
print(f"dado, 100000 lanci: media {rolls.mean():.3f}, varianza {rolls.var():.3f}")
p = 0.7
print(f"Bernoulli(0.7): media {p}, varianza p(1-p) = {p * (1 - p):.2f}, empirica {stats.bernoulli(p).rvs(100_000, random_state=2).var():.3f}")
g = stats.norm(loc=170, scale=10)
print(f"P(160 < X < 180) = {g.cdf(180) - g.cdf(160):.4f} P(150 < X < 190) = {g.cdf(190) - g.cdf(150):.4f}")
z = np.array([2.0, 1.0, 0.1]) # tre punteggi -> distribuzione categorica
q = np.exp(z) / np.exp(z).sum()
draws = rng.choice(3, size=100_000, p=q)
print("softmax:", np.round(q, 4), " frequenze:", np.round(np.bincount(draws) / draws.size, 4))
# Output:
# dado: E = 3.5, Var = 2.9167 (35/12 = 2.9167)
# dado, 100000 lanci: media 3.497, varianza 2.921
# Bernoulli(0.7): media 0.7, varianza p(1-p) = 0.21, empirica 0.209
# P(160 < X < 180) = 0.6827 P(150 < X < 190) = 0.9545
# softmax: [0.659 0.2424 0.0986] frequenze: [0.6597 0.2421 0.0981]
Il listato confronta ogni formula con un campione: varianza esatta del dado 2{,}9167 contro 2{,}921 da centomila lanci, varianza della Bernoulli p(1-p) = 0{,}21 contro 0{,}209, e le probabilità gaussiane 0{,}6827 e 0{,}9545 calcolate con la funzione di ripartizione (cdf). Le tre frequenze empiriche della softmax, estratte con rng.choice, coincidono con le probabilità alla terza cifra: è la verifica che «uscita della softmax» e «distribuzione categorica» sono la stessa cosa. Si usa default_rng con un seme esplicito perché i numeri casuali siano riproducibili.
Naive Bayes: classificare con la formula di Bayes
Il classificatore Naive Bayes applica il teorema di Bayes con un'ipotesi semplificatrice: date le classi, le feature sono indipendenti. In questo modo P(\text{classe} \mid x_1, \dots, x_d) \propto P(\text{classe}) \prod_i P(x_i \mid \text{classe}) e bisogna stimare solo una distribuzione per feature. Esempio a mano con due parole: prior 0,5; «gratis» compare nel 80% degli spam e nel 10% dei messaggi leciti; «offerta» nel 60% degli spam e nel 20% dei leciti. Un messaggio con entrambe ha punteggio spam 0{,}5 \cdot 0{,}8 \cdot 0{,}6 = 0{,}24 e lecito 0{,}5 \cdot 0{,}1 \cdot 0{,}2 = 0{,}01; normalizzando, P(\text{spam}) = 0{,}24/0{,}25 = 0{,}96.
import numpy as np
from sklearn.naive_bayes import GaussianNB
# 1) a mano: prior 0.5, P(gratis|spam)=0.8, P(gratis|ham)=0.1, P(offerta|spam)=0.6, P(offerta|ham)=0.2
spam = 0.5 * 0.8 * 0.6
ham = 0.5 * 0.1 * 0.2
print(f"spam ~ {spam:.3f} ham ~ {ham:.3f} P(spam | gratis, offerta) = {spam / (spam + ham):.2f}")
# 2) lo stesso schema con feature continue (conteggi di parole) e verosimiglianza gaussiana
X = np.array([[3, 2, 0], [4, 3, 1], [0, 0, 3], [1, 0, 4], [5, 4, 0], [0, 1, 2]], dtype=float)
y = np.array([1, 1, 0, 0, 1, 0]) # 1 = spam
x_new = np.array([2.0, 1.0, 2.0])
eps = 1e-9 * X.var(axis=0).max() # stessa regolarizzazione di scikit-learn
def log_post(c):
Xc = X[y == c]
mu, var = Xc.mean(axis=0), Xc.var(axis=0) + eps
ll = -0.5 * np.sum(np.log(2 * np.pi * var) + (x_new - mu) ** 2 / var)
return np.log(len(Xc) / len(X)) + ll
lp = np.array([log_post(0), log_post(1)])
prob = np.exp(lp - lp.max()); prob /= prob.sum() # normalizzazione: sottrarre il massimo evita l'underflow
print("a mano P(ham), P(spam):", np.round(prob, 6))
print("scikit-learn P(ham), P(spam):", np.round(GaussianNB().fit(X, y).predict_proba([x_new])[0], 6))
# Output:
# spam ~ 0.240 ham ~ 0.010 P(spam | gratis, offerta) = 0.96
# a mano P(ham), P(spam): [0.991832 0.008168]
# scikit-learn P(ham), P(spam): [0.991832 0.008168]
La seconda metà del listato è lo stesso schema con conteggi di parole e verosimiglianza gaussiana, implementato per esteso e confrontato con GaussianNB di scikit-learn: le due probabilità coincidono fino alla sesta cifra. Il punto tecnico sta nel lavorare con i logaritmi: un prodotto di molte probabilità piccole va in underflow, una somma di logaritmi no, e per normalizzare si sottrae il massimo prima di esponenziare (lo stesso trucco della softmax). L'ipotesi di indipendenza è raramente vera, e i conteggi di «gratis» e «offerta» tendono a comparire insieme; il classificatore funziona lo stesso come ordinatore, ma la guida di scikit-learn avverte che è un cattivo stimatore di probabilità: le uscite di predict_proba vanno trattate come punteggi, non come probabilità calibrate. Con solo tre campioni per classe, poi, le varianze stimate sono molto instabili: serve qualche decina di esempi per fidarsi.
Massima verosimiglianza: i parametri che rendono i dati più probabili
La stima di massima verosimiglianza (MLE) sceglie i parametri \theta che massimizzano la probabilità dei dati osservati. Per osservazioni indipendenti la verosimiglianza è il prodotto \mathcal{L}(\theta) = \prod_i P(x_i \mid \theta); si lavora col suo logaritmo, che trasforma il prodotto in somma e non cambia il punto di massimo: \ell(\theta) = \sum_i \log P(x_i \mid \theta). Si pone la derivata a zero. Per dati gaussiani il risultato è la media campionaria \hat\mu = \frac{1}{n}\sum x_i e la varianza \hat\sigma^2 = \frac{1}{n}\sum (x_i - \hat\mu)^2.
Con dieci altezze in cm, 168, 172, 175, 170, 173, 169, 171, 174, 176, 170, la somma è 1718 e la media 171{,}8. Gli scarti al quadrato sommano a 63{,}6, quindi la varianza MLE è 63{,}6/10 = 6{,}36. È una stima distorta: in media sottostima la varianza vera, e lo stimatore non distorto divide per n-1 e dà 63{,}6/9 \approx 7{,}0667. Nel limite di molti dati la differenza sparisce, con pochi no, ed è per questo che np.var ha il parametro ddof.
import numpy as np
data = np.array([168, 172, 175, 170, 173, 169, 171, 174, 176, 170], dtype=float)
n = len(data)
mu = data.mean()
print(f"media (MLE di mu) = {mu}")
print(f"varianza MLE (divide per n) = {data.var():.4f} (63.6 / 10)")
print(f"varianza non distorta (n-1) = {data.var(ddof=1):.4f} (63.6 / 9)")
# la media massimizza la log-verosimiglianza: controllo su una griglia
grid = np.linspace(165, 178, 13001)
sigma2 = data.var()
ll = -0.5 * n * np.log(2 * np.pi * sigma2) - ((data[:, None] - grid) ** 2).sum(axis=0) / (2 * sigma2)
print(f"massimo della log-verosimiglianza in mu = {grid[ll.argmax()]:.3f}")
# Bernoulli: etichette [1, 1, 0, 1]; -log-verosimiglianza media = cross-entropy binaria
labels = np.array([1, 1, 0, 1])
bce = lambda p: -np.mean(labels * np.log(p) + (1 - labels) * np.log(1 - p))
ps = np.linspace(0.01, 0.99, 981)
print(f"cross-entropy con p = 0.8 : {bce(0.8):.4f} con p = 0.75 : {bce(0.75):.4f}")
print(f"p che minimizza la cross-entropy: {ps[np.argmin([bce(q) for q in ps])]:.2f} (k/n = 3/4)")
# Output:
# media (MLE di mu) = 171.8
# varianza MLE (divide per n) = 6.3600 (63.6 / 10)
# varianza non distorta (n-1) = 7.0667 (63.6 / 9)
# massimo della log-verosimiglianza in mu = 171.800
# cross-entropy con p = 0.8 : 0.5697 con p = 0.75 : 0.5623
# p che minimizza la cross-entropy: 0.75 (k/n = 3/4)
Il listato verifica due cose. La prima è che la media è davvero il massimo: la log-verosimiglianza su una griglia fine ha il massimo in 171{,}8. La seconda è il legame che rende la MLE rilevante per l'apprendimento: per etichette binarie, la log-verosimiglianza negativa media di una Bernoulli è esattamente la cross-entropy binaria, -\frac{1}{n}\sum [y_i \log p + (1-y_i)\log(1-p)]. Con etichette (1, 1, 0, 1) e p = 0{,}8 vale (3 \cdot 0{,}2231 + 1{,}6094)/4 \approx 0{,}5697; con p = 0{,}75 scende a 0{,}5623 e questo è il minimo, in accordo con \hat p = k/n = 3/4. Minimizzare la cross-entropy è quindi la stessa cosa che massimizzare la verosimiglianza, e l'articolo sulle funzioni di perdita ne sfrutta le conseguenze.
Massima a posteriori: il prior diventa regolarizzazione
La stima MAP aggiunge alla verosimiglianza un prior sui parametri: \hat\theta_{\text{MAP}} = \arg\max_\theta [\log P(D \mid \theta) + \log P(\theta)]. Con un prior gaussiano P(\theta) = \mathcal{N}(0, \sigma_p^2) il termine -\log P(\theta) vale \theta^2/(2\sigma_p^2) più una costante: è una penalità quadratica sui pesi, cioè la regolarizzazione L2 (Ridge) con coefficiente 1/(2\sigma_p^2) rispetto alla log-verosimiglianza negativa. È la lettura probabilistica di una tecnica che si introduce spesso solo come trucco (si veda il §9.2.3 di Deisenroth e colleghi). Un prior piccolo, \sigma_p stretto, significa una penalità forte.
Per la media di una gaussiana con varianza \sigma^2 nota e prior \mathcal{N}(\mu_0, \sigma_p^2) il risultato è in forma chiusa, una media pesata fra i dati e il prior con pesi uguali alle «precisioni» n/\sigma^2 e 1/\sigma_p^2:
Con \sigma^2 = 6{,}36, \mu_0 = 170, \sigma_p^2 = 25 e le dieci altezze, n/\sigma^2 = 1{,}572 e 1/\sigma_p^2 = 0{,}04: il numeratore è 1{,}572 \cdot 171{,}8 + 0{,}04 \cdot 170 \approx 276{,}93, il denominatore 1{,}612, e \hat\mu_{\text{MAP}} \approx 171{,}76. Con una sola osservazione, x = 176, i pesi sono 0{,}157 e 0{,}04 e la stima diventa 34{,}47/0{,}197 \approx 174{,}78, molto più vicina al prior di quanto lo sia il dato.
import numpy as np
from scipy.optimize import minimize_scalar
data = np.array([168, 172, 175, 170, 173, 169, 171, 174, 176, 170], dtype=float)
sigma2 = data.var() # varianza nota (qui: stima MLE)
mu0, sp2 = 170.0, 25.0 # prior gaussiano sulla media: N(170, 5^2)
def map_mean(x): # forma chiusa: media pesata fra dati e prior
prec_data, prec_prior = len(x) / sigma2, 1 / sp2
return (prec_data * x.mean() + prec_prior * mu0) / (prec_data + prec_prior)
def neg_log_post(mu, x):
return np.sum((x - mu) ** 2) / (2 * sigma2) + (mu - mu0) ** 2 / (2 * sp2)
for x in (data, np.array([176.0])): # 10 osservazioni, poi una sola (176)
num = minimize_scalar(neg_log_post, args=(x,), bounds=(150, 190), method="bounded", options={"xatol": 1e-10}).x
print(f"n = {len(x):2d}: media dati = {x.mean():.2f} MAP formula = {map_mean(x):.4f} MAP numerico = {num:.4f}")
# Output:
# n = 10: media dati = 171.80 MAP formula = 171.7553 MAP numerico = 171.7553
# n = 1: media dati = 176.00 MAP formula = 174.7832 MAP numerico = 174.7832
Il listato confronta la formula chiusa con una minimizzazione numerica (minimize_scalar) del logaritmo del posterior negativo e le due coincidono alla quarta cifra. Il comportamento che conta è la dipendenza da n: con dieci dati il prior sposta la stima di soli 0{,}05 cm, con uno solo di 1{,}2 cm. Più dati ci sono, più il prior pesa poco; la regolarizzazione agisce quando i dati sono pochi rispetto ai parametri, che è il caso dell'overfitting. La scelta del prior (qui 170 con deviazione 5) è soggettiva, e un prior sbagliato e forte, con pochi dati, sposta la stima nel posto sbagliato.
Teorema del limite centrale: perché la gaussiana è ovunque
Il teorema del limite centrale dice che la media \overline{X}_n di n variabili indipendenti e identicamente distribuite con media \mu e varianza finita \sigma^2 tende, al crescere di n, a una gaussiana \mathcal{N}(\mu, \sigma^2/n), qualunque sia la distribuzione di partenza. La deviazione standard della media cala come 1/\sqrt{n}: serve quadruplicare i dati per dimezzare l'incertezza. Esempio: variabili esponenziali con media 1 e deviazione 1, molto asimmetriche; la media di 30 osservazioni dovrebbe avere deviazione 1/\sqrt{30} \approx 0{,}183.
import numpy as np
rng = np.random.default_rng(3)
# esponenziale con media 1: molto asimmetrica (asimmetria 2). Medie di n = 30 osservazioni.
n, reps = 30, 100_000
means = rng.exponential(1.0, size=(reps, n)).mean(axis=1)
skew = lambda v: np.mean(((v - v.mean()) / v.std()) ** 3)
single = rng.exponential(1.0, size=reps)
print(f"singola osservazione: media {single.mean():.3f} std {single.std():.3f} asimmetria {skew(single):.2f}")
print(f"media di 30: media {means.mean():.3f} std {means.std():.3f} (1/sqrt(30) = {30 ** -0.5:.3f}) asimmetria {skew(means):.2f}")
print(f"quota entro 1.96 std dalla media: {np.mean(np.abs(means - 1) < 1.96 * 30 ** -0.5):.4f} (gaussiana: 0.95)")
# Output:
# singola osservazione: media 1.005 std 1.004 asimmetria 2.03
# media di 30: media 1.001 std 0.183 (1/sqrt(30) = 0.183) asimmetria 0.38
# quota entro 1.96 std dalla media: 0.9510 (gaussiana: 0.95)
Centomila medie di 30 osservazioni danno deviazione 0{,}183, come previsto, e l'asimmetria scende da 2{,}03 a 0{,}38: la distribuzione non è ancora perfettamente simmetrica, ma la quota di medie entro 1{,}96 deviazioni standard dalla media vale 0{,}951, quasi il 0{,}95 della gaussiana. Il risultato giustifica che si usino intervalli di confidenza gaussiani per le medie (articolo sulla statistica inferenziale). Richiede la varianza finita e indipendenza, e con n piccolo o code pesanti l'approssimazione può essere pessima: le asimmetrie residue qui sono la prova che n = 30 non è una soglia magica.
Il test d'ipotesi: la stessa domanda con un'altra logica
Un test d'ipotesi risponde a una domanda diversa da Bayes: non «quanto è probabile l'ipotesi» ma «quanto sarebbero sorprendenti questi dati se l'ipotesi nulla fosse vera». Il p-value è la probabilità, calcolata sotto l'ipotesi nulla, di ottenere un risultato almeno estremo quanto quello osservato. Non è la probabilità che l'ipotesi nulla sia vera. Esempio: una moneta dà 9 teste su 10 lanci; ipotesi nulla p = 0{,}5. I casi con 9 o 10 teste sono \binom{10}{9} + \binom{10}{10} = 11 su 2^{10} = 1024, quindi P(X \geq 9) = 11/1024 \approx 0{,}0107; contando anche gli estremi opposti (0 o 1 teste) il p-value a due code raddoppia e vale 0{,}0215.
import numpy as np
from scipy import stats
# Test binomiale esatto: 9 teste su 10 lanci, ipotesi nulla p = 0.5
k, n = 9, 10
p_one = sum(stats.binom.pmf(j, n, 0.5) for j in range(k, n + 1))
print(f"P(X >= 9 | p = 0.5) = {p_one:.4f} (11/1024 = {11 / 1024:.4f})")
print(f"p-value a due code (scipy) = {stats.binomtest(k, n, 0.5).pvalue:.4f}")
# Stessi dati, lettura bayesiana: prior uniforme Beta(1,1) -> posterior Beta(1+9, 1+1)
post = stats.beta(1 + k, 1 + n - k)
print(f"P(p > 0.5 | dati) = {1 - post.cdf(0.5):.4f} media a posteriori = {post.mean():.4f}")
print(f"intervallo credibile al 95%: {np.round(post.interval(0.95), 3)}")
# Output:
# P(X >= 9 | p = 0.5) = 0.0107 (11/1024 = 0.0107)
# p-value a due code (scipy) = 0.0215
# P(p > 0.5 | dati) = 0.9941 media a posteriori = 0.8333
# intervallo credibile al 95%: [0.587 0.977]
Il listato calcola il p-value due volte, sommando le probabilità binomiali e con binomtest, e poi guarda gli stessi dati in ottica bayesiana: un prior uniforme \mathrm{Beta}(1,1) diventa, dopo 9 teste e 1 croce, un posterior \mathrm{Beta}(10, 2), per il quale P(p > 0{,}5 \mid \text{dati}) = 0{,}9941 e l'intervallo credibile al 95% è [0{,}587;\ 0{,}977]. I due numeri, 0{,}0215 e 0{,}9941, rispondono a domande diverse e non vanno confusi: il primo non dice che la moneta è truccata con probabilità 97{,}85\%. Soglie come 0{,}05 sono convenzioni, non leggi, e con molti test eseguiti qualcuno supererà la soglia per caso; gli intervalli di confidenza e il test A/B sono sviluppati nell'articolo successivo sulla statistica inferenziale.
Che cosa sai fare adesso
Sai invertire un condizionamento con il teorema di Bayes e controllare il risultato con una simulazione, sai riconoscere in una softmax una distribuzione categorica e in una cross-entropy una log-verosimiglianza negativa, e sai leggere la regolarizzazione L2 come il prior gaussiano di una stima MAP il cui peso diminuisce al crescere dei dati. Sai anche distinguere un p-value da un posterior. Il passo successivo è usare il gradiente per cercare questi parametri: l'articolo sull'ottimizzazione parte dalla discesa del gradiente su una log-verosimiglianza negativa.
Fonti
- Deisenroth, Faisal, Ong, Mathematics for Machine Learning (2020), capitoli 6 e 9 - regola della somma e prodotto, teorema di Bayes (§6.3), gaussiana (§6.5), massima verosimiglianza e MAP come regolarizzazione (§9.2.3); PDF letto, consultata il 2026-11-12
- scikit-learn User Guide: Naive Bayes - l'ipotesi di indipendenza condizionale fra le feature e la classe GaussianNB usata per il confronto, consultata il 2026-11-12
- SciPy: scipy.stats.binomtest - definizione del test binomiale esatto usato per il p-value a due code, consultata il 2026-11-12
- Goodfellow, Bengio, Courville, Deep Learning, capitolo 3 (Probability and Information Theory) - riferimento per distribuzioni, Bernoulli, categorica e gaussiana; pagina raggiunta, consultata il 2026-11-12

Commenti
Caricamento commenti...
Accedi per commentare