Esercizio - Eliminazione di variabili nella rete burglary (slide del corso)
Testo (esercizio costruito sulle slide Bayesian Networks (part 1), corso di Intelligenza Artificiale, Ing. dell'Informazione UniPD, che chiudono l'esempio dell'enumerazione proponendo di "salvare e riusare i risultati intermedi, cioè l'algoritmo di variable elimination"). Sulla rete dell'allarme (stesse CPT di Esercizio - Inferenza per enumerazione nella rete burglary (slide del corso)):
- Calcolare (Giovanni chiama, dato che Maria ha chiamato) con l'eliminazione di variabili, scrivendo ogni fattore intermedio.
- Mostrare quali prodotti dell'enumerazione di vengono riusati dall'eliminazione.
Soluzione
Query 1: . Variabili nascoste: . Si sceglie l'ordine di eliminazione .
Passo 1: eliminare . I fattori che contengono sono e . Si moltiplicano e si somma su : .
- ;
- ;
- e (le colonne sommano a perché è ancora una probabilità di dato ).
Passo 2: eliminare . Fattori con : e . : Il fattore è la distribuzione marginale dell'allarme: .
Passo 3: eliminare . Fattori con : , e . Il prodotto è una tabella su e e la somma su la riduce a un vettore su : .
- ;
- .
Passo 4: normalizzare. e Interpretazione: : se Maria chiama, è più probabile che l'allarme sia suonato e che chiami anche Giovanni (fork : e sono dipendenti se non si osserva ).
Query 2: quali prodotti si riusano. Nell'enumerazione di compaiono, sotto e sotto (e di nuovo per ), gli stessi prodotti e : nell'albero delle slide sono i rami cerchiati in rosa e in verde. L'eliminazione li calcola una sola volta, come fattore , poi forma la tabella (otto numeri: , , , per ) e infine . Moltiplicando per : , uguale al risultato dell'enumerazione.
Ordine di eliminazione. L'ordine dà lo stesso risultato: eliminando prima si forma con e ; poi si elimina e infine , e si ottiene ancora (verificato). Cambia il costo, perché in reti più grandi alcuni ordini creano fattori più grandi: il costo dipende dalla dimensione del fattore più grande che si forma, non dal risultato.
Codice
import numpy as np
# fattori della rete burglary; ogni asse e' una variabile, indice 0 = vero, 1 = falso
f_B = np.array([0.001, 0.999]) # f_B(B)
f_E = np.array([0.002, 0.998]) # f_E(E)
f_A = np.zeros((2, 2, 2)) # f_A(A, B, E) = P(A | B, E)
for (b, e), p in {(0, 0): .95, (0, 1): .94, (1, 0): .29, (1, 1): .001}.items():
f_A[0, b, e], f_A[1, b, e] = p, 1 - p
f_J = np.array([[0.90, 0.05], [0.10, 0.95]]) # f_J(J, A) = P(J | A)
f_M = np.array([[0.70, 0.01], [0.30, 0.99]]) # f_M(M, A) = P(M | A)
# Query: P(J | m). Evidenza m: si fissa M = vero, f_M diventa un fattore su A soltanto
f_m = f_M[0, :] # <P(m|a), P(m|~a)> = <0.7, 0.01>
# 1) eliminare B: g1(A, E) = sum_b f_B(b) f_A(A, b, E)
g1 = np.einsum('b,abe->ae', f_B, f_A)
# 2) eliminare E: g2(A) = sum_e f_E(e) g1(A, e) (e' la marginale P(A))
g2 = np.einsum('e,ae->a', f_E, g1)
# 3) eliminare A: h(J) = sum_a g2(a) f_m(a) f_J(J, a)
h = np.einsum('a,a,ja->j', g2, f_m, f_J)
print("g1\n", g1); print("g2", g2); print("h", h, h / h.sum())Output: g1 = [[0.29066 0.001939] [0.70934 0.998061]], g2 = [0.0025164 0.9974836], h = [0.0020841 0.0096522] e distribuzione [0.1775766 0.8224234]. np.einsum esegue in un colpo prodotto puntuale e somma: 'b,abe->ae' moltiplica per e somma sull'indice che non compare nel risultato. Verificato con l'enumerazione sulla congiunta completa: .
Versione ripasso
- Fattori: ; l'evidenza trasforma in .
- Passo di eliminazione di variabilimoltiplicare i fattori che contengono la variabile e sommarlaReti bayesiane - semantica, indipendenze e inferenza esatta →: per ogni nascosta, nell'ordine scelto.
- , ordine : : (), (); (marginale di ); .
- Risultato: (contro : e dipendenti senza ).
- Riuso: calcolato una volta sola; con otto numeri, , risultato come l'enumerazione.
- Errori tipici: sommare una variabile prima di aver moltiplicato tutti i fattori che la contengono; dimenticare che l'evidenza riduce i fattori; credere che l'ordine cambi il risultato (cambia solo il costo).
- Fork: : e dipendenti se non è osservato. Ordine : , , stesso risultato.
einsum:'b,abe->ae'moltiplica e somma sull'indice che non compare nel risultato.