Rreti neurali artificiali (ANN)

Reti Neurali Artificiali (ANN)
Edmondo Trentin
24 maggio 2010
Autore: Edmondo Trentin
Prima trascrizione digitale: Pierluigi Failla (dagli originali di E.T.)
Definizione di ANN
La definizione di ANN viene data in 3.1 punti. Una
ANN e’ infatti una macchina completamente
specificata una volta che ne siano state definite:
1. architettura
2. dinamica
3. apprendimento
3.1 generalizzazione
Nel seguito daremo quindi una definizione di
ciascuna di queste quantita’.
ANN: architettura
Una rete neurale è un grafo (diretto oppure no) A = (V , E ) i cui
vertici v ∈ V si dicono unità o neuroni e i cui archi E si dicono
connessioni (sinaptiche). V ha tre sottoinsiemi: I ⊆ V le unità di
input; O ⊆ V le unità di output e H ⊂ V le unità nascoste
(hidden), queste ultime tali che H ∩ I = H ∩ O = ⊘.
Il grafo è etichettato, sia sugli archi che sui vertici: le etichette
degli archi, detti pesi, sono scalari w ∈ R; le etichette dei nodi
sono funzioni a valori reali dette funzioni di attivazione.
Tipiche funzioni di attivazione f (.) : R → R
◮
Funzione a soglia (o a scalino) detta anche Threshold Logic
Unit (TLU):
◮
Funzioni lineari f (a) = a o f (a) = wa + r :
◮
Sigmoidi f (a) = 1/(1 + e −a ) con 0 < f (a) < 1:
◮
Sigmoidi f (a) = tanh(a) con −1 < f (a) < 1:
◮
Gaussiane f (a) = N(a; 0, 1):
Tipiche funzioni di attivazione f (.) : Rd → R
◮
Campi scalari, quali gaussiane multivariate (kernel)
f (a) = N(a; µ, Σ):
L’architettura, o topologia, di una ANN è dunque specificata da
(V , E , I , O, H) e dalle etichette {w } e {f (·)}:
ANN: dinamica
Definita l’architettura, la definizione di ANN prosegue con la
definizione di una dinamica della stessa, che descrive come il
segnale si propaga attraverso la rete, ovvero di come la ANN
prende vita.
1. la rete riceve un input x dal mondo esterno, x = (x1 , ..., xd ).
La ANN deve avere d input unit, |I | = d e xi è l’input per la
i-esima input unit. Le input unit non trasformano il segnale,
ma lo inviano lungo le connessioni in uscita verso altri neuroni.
2. nell’attraversare la connessione con peso w , il segnale o
subisce una trasformazione, tipicamente una moltiplicazione
per w .
3. sia j una generica unità in H ∪ O, questa riceve tanti segnali
w1 o1 , ..., wn on quante sono le connessioni in ingresso. Ci sono
due fasi:
3.1 la funzione di attivazione associata all’unità j è scalare,
f : R → R. In questo caso si calcola l’input aj come somma
pesata di tutti i segnali in ingresso.
aj =
n
X
wi oi
(1)
i=1
e si applica f (·), quindi oj = f (aj ) che viene a sua volta
propagato.
3.2 la f (·) associata a j è del tipo f : Rn → R. Allora si applica la
f (·) al vettore a = (w1 o1 , ..., wn on ) da cui oj = f (a) ad
esempio una gaussiana valutata su a.
4. il segnale si propaga attraverso tutta la rete secondo le
precedenti regole, fino ad arrivare alle unità di output. Sia k
una unità di output (k ∈ O). Il valore ok si assume come
output k-esimo della rete. Se la ANN ha m output unit, si
considerano le sue uscite come un unico vettore
m-dimensionale: Y = (y1 , ..., ym )
Nota: il trigger temporale della ANN dipende dalla particolare
famiglia di reti.
Osservazione: la ANN può essere vista come un particolare
paradigma di calcolo (come un computer o una macchina di
Turing...) analogico dove le unità sono semplici processori. La
topologia della ANN specifica l’architettura hardware, il particolare
valore dei pesi w ne determina il funzionamento (cioè la funzione
calcolata) e ne costituisce il software, mentre la dinamica (la
macchina che prende vita) rappresenta il processo in running.
ANN: apprendimento e generalizzazione
La definizione di ANN, una volta specificata l’architettura e la
dinamica, prosegue introducendo la caratteristica principale delle
ANN: l’apprendimento.
Le ANN apprendono per esempi da una training set τ = {z}.
Esistono tre istanze di learning:
◮
apprendimento supervisionato, τ = {(x, y )}
◮
apprendimento non supervisionato τ = {x}
◮
apprendimento per rinforzo (reinforcement learning)
τ = {x1 , x2 , ...(xt , y ), xt+1 , ...}, ogni tanto viene dato un
segnale di rinforzo (il premio o la penalità)
L’apprendimento è inteso come un processo di progressiva
modificazione dei pesi in modo da evitare la semplice
memorizzazione degli esempi, bensı̀ viene fatto in modo da
ottenere l’inferenza della legge (universale) soggiacente ai dati, in
modo da poterla generalizzare a nuovi dati non visti durante il
training (capacità di generalizzazione).
MultiLayer Perceptron (MLP)
◮
◮
◮
◮
Architettura a strati (layer) con propagazione in avanti
(feed-forward) e completamente connessa (fully connected).
Funzioni di attivazione f : R → R tipicamente sigmoidi e/o
lineari. Le unità di un dato layer condividono la stessa forma
per la funzione di attivazione.
Dinamica: propagazione simultanea (senza ritardi) dall’input
layer all’output layer, attraverso nessuno o più hidden layer.
Apprendimento: supervisionato, tramite il metodo del
gradiente (backpropagation).
Caso particolare: Simple Perceptron (SP)
◮
◮
◮
Convenzione: negli MLP il layer di input non si conta (agisce
da placeholder) quindi SP è una 1-layer ANN.
Notazione: il peso della connessione tra la j-esima input unit e
la i-esima output unit si denota con wij
Funzione calcolata: sia f : R → R la funzione di attivazione
associata alle output unit allora:
d
X
wij xj )
yi = f (ai ) = f (
j=1
◮
Caso P
particolare: se f è lineare allora si ha
yi = j wij xj = wi t x (Simple Linear Perceptron)
(2)
SP Apprendimento: delta rule
◮
◮
Training set τ = {(x, yb) : x ∈ Rd , yb ∈ Rm }
Criterion function batch: C (τ, W ) dove
W = {wij | i = 1, . . . , m j = 1, . . . , d}
◮
◮
Una volta fissato τ abbiamo
P Pm
yi − yi )2
C (τ, W ) = C (W ) = 21 τ i=1 (b
In pratica si usa on-line learning, riducendosi alla seguente
criterion function:
m
1X
C (W ) =
(b
yi − yi )2
2
(3)
i=1
◮
da minimizzare iterativamente su ogni singolo esempio
Gradient-descent prescrive la regola delta:
∆wij = −η
∂C
∂wij
(4)
che consente di aggiornare un generico peso dal valore attuale
′
wij al nuovo valore wij = wij + ∆wij
′
Vettorialmente: w = w − η∇w C (w )
∂C
. Sia fi (ai ) la funzione di attivazione associata
Calcoliamo ora: ∂w
ij
alla i-esima unità di output. Dunque:
)
( m
∂
1X
∂C
2
(b
yk − y k )
(5)
=
∂wij
∂wij 2
k=1
=
m
1X ∂
(b
yk − yk )2
2
∂wij
k=1
1 ∂
=
(b
yi − yi )2
2 ∂wij
∂yi
= −(b
yi − y i )
∂wij
∂C
Poiche’ ∆wij = −η ∂w
, dall’Eq. (5) si ha:
ij
∆wij = η(b
yi − y i )
Procedo ora al calcolo di
∂yi
∂wij .
∂yi
∂wij
(6)
∂yi
∂wij
=
=
∂fi (ai )
∂wij
∂fi (ai ) ∂ai
∂ai ∂wij
d
′
= fi (ai )
∂ X
wik xk
∂wij
k=1
′
= fi (ai )xj
∂yi
Poiche’ ∆wij = η(b
yi − yi ) ∂w
, la delta rule assume la forma:
ij
∆wij
′
= η(b
yi − yi )fi (ai )xj
= ηδi xj
′
avendo definito δi = (b
yi − yi )fi (ai ).
′
Se f (.) è lineare si ha fi (ai ) = 1, dunque ∆wij = η(b
yi − yi )xj
MLP: Backpropagation
◮
◮
◮
◮
Training set: τ = {(xt , ybt ) : t = 1, ..., n}
Criterion function batch:
P
P
2
C (τ, w ) = C (W ) = 12 nt=1 m
i=1 (ybi − yi )
P
2
Criterion function online: : C (W ) = 12 m
i=1 (ybi − yi )
Per un generico peso w nel MLP usiamo gradient descent:
′
∂C
.
w = w + ∆w con ∆w = −η ∂w
◮
Indichiamo con fi (ai ) la funzione di attivazione associata
all’i-esima unità.
◮
Assumiamo che la rete abbia ℓ layer: L0 denota l’input layer,
L1 , ..., Lℓ−1 gli hidden layer, Lℓ l’output layer. Scriveremo
k ∈ Lj per dire che ci riferiamo alla k-ima unità del j-imo
layer.
◮
∂C
per un generico peso w del
Vogliamo calcolare ∆w = −η ∂w
MLP
Caso 1: w nell’output layer
Sia w = wij , con j ∈ Lℓ−1 e i ∈ Lℓ . Si ha:
( m
)
∂
1X
∂C
=
(ybk − yk )2
∂wij
∂wij 2
k=1
=
m
1X ∂
(ybk − yk )2
2
∂wij
k=1
1 ∂
=
(ybi − yi )2
2 ∂wij
∂yi
= −(ybi − yi )
∂wij
∂yi
∂wij
∂fi (ai ) ∂ai
∂ai ∂wij
∂ X
′
wik ok
= fi (ai )
∂wij
=
k
′
= fi (ai )oj
Riassumendo,
◮ ∂C
∂wij
◮ ∂yi
∂wij
da cui:
∂yi
= −(ybi − yi ) ∂w
ij
′
= fi (ai )oj
′
∆wij = η(ybi − yi )fi (ai )oj
Quindi, se i ∈ Lℓ e j ∈ Lℓ−1 , definendo
′
δi = (ybi − yi )fi (ai )
si ottiene la seguente delta rule:
∆wij = ηδi oj
(7)
dove oj = fj (aj ).
Ovviamente, è la stessa regola di apprendimento che avevamo con
SP, con la differenza che abbiamo oj al posto di xj .
Caso 2: w in un hidden layer
Per fissare le idee, poniamo w = wjk con j ∈ Lℓ−1 e k ∈ Lℓ−2 (i
seguenti risultati valgono in realtà per tutti i successivi layer
∂C
nascosti Lℓ−3 , ..., L0 ). Vogliamo ∆wjk = −η ∂w
. Si ha:
jk
∂C
∂wjk
=
=
=
=
( m
)
∂
1X
(ybi − yi )2
∂wjk 2
i=1
( m
)
∂oj
∂
1X
2
(ybi − yi )
∂oj 2
∂wjk
i=1
)
( m
∂oj
1X ∂
(ybi − yi )2
2
∂oj
∂wjk
i=1
)
( m
X
∂oj
∂yi
(ybi − yi )
−
∂oj ∂wjk
i=1
Andiamo innanzitutto a calcolare
∂yi
∂oj .
∂fi (ai ) ∂ai
∂ai ∂oj
∂ X
′
= fi (ai )
wij oj
∂oj
∂yi
∂oj
=
j
′
= fi (ai )wij
da cui, poiche’
∂C
∂wjk
∂C
∂wjk
n P
o
∂oj
∂yi
b
= − m
(
y
−
y
)
i
i
i=1
∂oj
∂wjk , si ottiene:
=
(
= −
= −
−
Ã
m
X
i=1
m
X
Ã
′
(ybi − yi )fi (ai )wij
wij δi
i=1
m
X
i=1
wij δi
!
!
)
∂fj (aj ) ∂aj
∂aj ∂wjk
′
fj (aj )ok
∂oj
∂wjk
∂C
e
Dunque ∆wjk = −η ∂w
jk
Possiamo quindi scrivere:
∂C
∂wjk
∆wjk = η
Ponendo δj = (
P
′
= −( m
i=1 wij δi ) fj (aj )ok .
à m
X
i=1
Pm
i=1 wij δi ) fj
′
wij δi
!
′
fj (aj )ok
(8)
(aj ) si ottiene la delta rule:
∆wjk = ηδj ok
(9)
che ha la stessa forma del caso 1. Per qualunque peso wjk di
qualunque layer si può dunque applicare la delta-rule
generalizzata ∆wjk = ηδj ok , a patto di definire:
δj =
(
′
(ybj − yj )fj (aj )
se j ∈ Lℓ
P
′
( i∈Lk+1 wij δi )fj (aj ) se j ∈ Lk con k = ℓ − 1, ..., 0
L’apprendimento procede per epoche successive sul training set
(un’epoca e’ un ciclo di applicazione della delta-rule su tutti i dati
di τ )
Criteri di arresto
1. dopo un numero prefissato di epoche
2. quando l’errore C scende sotto una certa soglia: C < ǫ
3. quando il guadagno ∆C scende sotto una certa soglia:
∆C < ǫ
4. verificando tramite cross validation la capacità di
generalizzazione. In particolare:
Curva di apprendimento: errore misurato sul training-set.
Curva di generalizzazione: errore misurato sul validation-set.
Un fenomeno analogo si ha all’aumentare della complessità della
macchina (Vapnik-Chervonenkis Dimension)
Aspetti pratici e approfondimenti
1. I pesi vanno inizializzati a caso in un range piccolo, centrato
in zero: wij ∈ [−ε, ε] per evitare la saturazione delle sigmoidi:
2. Per lo stesso motivo, oltre che per ragioni di stabilità
numerica, i valori di input [x1 , x2 , ..., xd ] devono essere
normalizzati. Ad esempio: xi ∈ [0, 1] oppure xi ∈ [−1, 1].
Una scelta tipica che garantisce valori a media nulla in [−1, 1]
è, per ogni i, sottrarre la media e dividere per il massimo in
modulo.
3. Se si usano sigmoidi in output, anche i target output devono
essere normalizzati, [0, 1].
4. Regolarizzazione: si modifica il learning in modo da favorire
la capacità di generalizzazione. Un’idea è quella di forzare la
macchina ad essere il meno complessa possibile (con ridotta
VC-dimension):
4.1 weight-sharing: alcune connessioni sono forzate a condividere
lo stesso valore w per il proprio peso, e ∆w è calcolata
mediando sui diversi valori prodotti dalla delta-rule per le
diverse istanze di w
4.2 weight-decay: pesi numericamente più piccoli implicano
soluzioni più semplici:
C=
1X
αX
(ybi − yi )2 +
(wij )2
2
2
i
(10)
i,j
P
dove α2 i,j (wij )2 e’ il termine di regolarizzazione. Per un
generico w si ha
ª
©1 P
∂C
∂
bi − yi )2 − ηαw ovvero,
∆w = −η ∂w
= −η ∂w
i (y
2
nell’apprendere il nuovo valore di w oltre al solito ∆w dovuto
alla delta-rule, si sottrae una frazione ηα dello stesso w .
5. Usiamo funzioni di attivazione più flessibili:
f (a) =
λ
1+
e −(a−b)/θ
◮
λ è l’ampiezza:
◮
θ è la smoothness (importante per i valori della derivata):
◮
b è il bias (o offset):
Esistono algoritmi (gradient-descent) per apprendere λ, θ, b. In
particolare il bias può essere appreso come un peso introducendo
un’unità di diagonalizzazione di uscita costante e unitaria.
Figura: Bias
6. Si può rendere più stabile l’apprendimento introducendo nella
delta-rule un’inerzia o momentum term:
∆w (t + 1) = −η
∂C
+ ρ∆w (t)
∂w (t)
(11)
con ρ ∈ (0, 1)
Un MLP supervised apprende una trasformazione
φ : Rd → Rm che trova applicazione nei seguenti
domini:
◮ approssimazione funzionale: y = φ(x)
◮ regressione (lineare o non-lineare):
y = φ(x) + ǫ, con ǫ rumore gaussiano
◮ classificazione: yi = gi (xi )
In 2-class classification, in particolare:
dove y = g (x) = u t x + v . In pratica il Simple Linear Perceptron è
un discriminante lineare (Widrow-Hoff algorithm: yb = 1/ − 1 a
seconda che il pattern appartenga o meno alla classe in esame). E’
facile capire che se la rete ha c uscite (per c classi), i valori delle
connessioni del bias saranno diverse per ogni uscita e otterremo
qualcosa del tipo: gi (x) = ui t x + vi , per ogni i tra 0 e c.
Se usiamo un MLP sullo stesso training set etichettato con
ybi = 0/1 (oppure ybi = −1/1) otteniamo funzioni discriminanti (se
l’output layer è lineare allora si tratta di un Generalized Linear
Discriminant) non lineari con superfici di separazione più flessibili:
Figura: Superfici di separazione non lineari
non necessariamente connesse e/o convesse.
Principio di universalità degli MLP1 (Cybenko, Lippmann,
1989): un MLP con un layer hidden di sigmoidi e un output layer
lineare è un’architettura universale, ovvero se ∀ϕ : Rd → Rm con ϕ
continua, ∃ un siffatto MLP che approssima ϕ(·) “arbitrariamente
bene”.
Nota 1: arbitrariamente bene significa che ∀ε ∈ R+ , piccolo a
piacere, la funzione calcolata dal MLP in questione h : Rd → Rm è
tale che, ∀x ∈ Rd , kϕ(x) − h(x)k < ε.
Nota 2: la proprietà asserisce che esiste un MLP... ma non dice:
◮
quanti neuroni ha;
◮
che valore hanno i suoi pesi;
◮
se e come è possibile apprendere i pesi in questione.
Tuttavia la proprietà di universalità ci conforta e ci suggerisce di
usare MLP come una macchina molto flessibile. L’MLP usato per
classificazione con target 0/1 (oppure -1/1) per l’uscita i-esima
che modella gi (x) è dunque uno stimatore non parametrico
(discriminante lineare generalizzato) e backpropagation è
un’estensione dell’algoritmo di Widrow Hoff.
1
NdA: http://en.wikipedia.org/wiki/Cybenko_Theorem
Mixture of Experts
Possiamo combinare modularmente k esperti neurali E1 , E2 , ..., Ek :
Ogni Ei è un MLP che calcola la funzione yi = ϕi (x). Il modello
complessivo è dunque:
y=
k
X
αi ϕi (x)
(12)
i=1
con αi ∈ [0, 1]. αi è il credito assegnato dal gather ad Ei a fronte
dell’input x.
(i) Il feature space può essere partizionato (divide et impera) in k
regioni disgiunte A1 , A2 , ..., Ak ed Ei è specializzato su Ai .
Il gather può dunque assegnare i crediti in questo modo: se x ∈ Ai
allora αi = 1 e 0 tutti gli altri (sia durante il training che durante il
test).
(ii) Anziché regioni rigide Ai , possiamo avere “classi” ω1 , . . . , ωk
con certe pi (x|ωi ), ad esempio p(x|ωi ) = N(x; µ, Σ) (regioni con
overlap).
Il gather può dunque
αi = P(ωi |x) sotto
Pk assegnare creditoPcome:
k
la condizione che j=1 αj = 1 e y = i=1 P(ωi |x)ϕi (x) (sia in
training che in test).
Dobbiamo possedere un modello (stimatore) per P(ωi |x). Le
tecniche statistiche bayesiane possono essere applicate a questo
proposito: si tratta di un importante esempio di ibridazione tra
approcci statistici e neurali.
(iii) Anzichè fissare regioni o classi a priori, possiamo apprendere
la gathing function durante il training modellandola con una
gathing network (arbitro) la cui uscita i-esima è il credito αi (x):
La gathing network viene addestrata parallelamente agli esperti, i
pesi αj da essa generati vengono usati sia durante il training (per
pesare l’errore) che durante il test.
Autoassociatore
E’ un MLP che mappa gli input su loro stessi τ = {(x, x)}, si può
vedere come un esempio di apprendimento non-supervisionato.
Addestramento
1. Si addestra con BP a mappare x su x
2. Le unità centrali sono dunque una rappresentazione a
dimensionalità ridotta dello spazio delle feature
3. Buttiamo via i layer alti:
In pratica abbiamo realizzato un estrattore di feature
(dimensionality reduction), ovvero uno stimatore
non-parametrico di tipo 3 ( alla Fisher) che proietta i dati su un
sotto-spazio a dim. ridotta.
Spingiamoci oltre in questo gioco:
1. sia Rd lo spazio delle feature e sia
τ = {(x, yb)|x ∈ Rd , yb ∈ Rm }. Vogliamo addestrare un MLP
che realizzi ϕ : Rd → Rm su τ .
2. innanzitutto da τ costruiamo
′
τ = {(x, x)|(x, yb) ∈ τ per qualche yb} e addestriamo
′
l’autoassociatore su τ
b
3. smontiamo l’autoassociatore e proiettiamo Rd su Rd . Da τ
′′
b
otteniamo τ = {(z, yb)|z ∈ Rd }. In pratica prendiamo gli
esempi di τ e ne filtriamo la componente x ∈ Rd
b
proiettandola, via autoassociatore spezzato, su z ∈ Rd
′′
4. addestriamo finalmente (come richiesto) un MLP su τ con
b
backpropagation on-line in modo che realizzi ϕ
b : Rd → Rm
5. montiamo i due MLP l’uno sull’altro, tenendone fissi i pesi,
ottenendo la ϕ : Rd → Rm desiderata
6. i pesi della rete combinata (punto 5) possono essere raffinati
con ulteriori epoche di backpropagation su τ , migliorando il
modello di ϕ
MLP: decisioni e stime di probabilità
Ci sono due modi di usare un MLP come stimatore non
parametrico per pattern recognition:
1. usiamo degli MLP come funzioni discriminanti: come nei
discriminanti lineari con Widrow-Hoff, etichettiamo il training
set con target output 0/1 e assumiamo che l’output unit i-ima
del MLP rappresenti gi (x)
2. interpretazione probabilistica degli output: addestro uno (o
piu’) MLP per stimare (in modo non-parametrico) le quantita’
probabilistiche da usare nel teorema di Bayes (P(ωi |x) o
p(x | ωi )).
L’output di un MLP può essere interpretato come una probabilità
se e solo se esso si trova nel range [0, 1]. Questo è garantito se si
usano funzioni di attivazione sigmoidali.
Se abbiamo c uscite e vogliamo che siano rispettivamente
P(ω1 |x), P(ω2 |x), P
..., P(ωc |x) allora deve anche essere verificato il
c
seguente vincolo:
i=1 P(ωi |x) = 1. Questo può essere garantito
ponendo:
b i |x) = Pcyi (x)
P(ω
(13)
j=1 yj (x)
dove yj (x) è la j-esima uscita della ANN a fronte dell’input2 x.
Problema: che target-output usiamo per addestrare in maniera
supervisionata l’MLP a modellare P(ωi |x)? Viene in nostro
soccorso il seguente:
Teorema (Lippmann, Richard): usando come target-output per
l’unità i-esima i valori 0 (se x ∈
/ ωi ) e 1 (se x ∈ ωi ), la
minimizzazione del criterio C (w ) (scarto quadratico) equivale a
minimizzare lo scarto quadratico tra output i-esimo e P(ωi |x).
2
E’ opportuno usare questa espressione anche durante il training.
e)
In altre parole se riusciamo a trovare il minimo globale CMIN (w
e coincide con
con etichette 0/1, siamo certi che l’MLP con pesi w
lo stimatore bayesiano ottimo.
In pratica: usando backpropagation su dati reali non arriviamo mai
al minimo globale, quindi l’uscita i-esima non coincide
mai con
P
P(ωi |x). In particolare, quindi, non è detto che ci=1 yi (x) = 1.
P b
Per questo è necessario imporre il vincolo i P(ω
i |x) = 1
esplicitamente.
Un altro modo per garantire il rispetto del vincolo è quello
(SOFTMAX) di prendere:
b i |x) ≃ yi (x) = Pce
P(ω
ai
j=1 e
aj
(14)
Posso usare MLP anche per stimare le class-conditional pdf?
Poiché
p(x|ωi )P(ωi )
(15)
yi (x) ≃ P(ωi |x) =
p(x)
si ha che
p(x|ωi )
yi (x)
≃
P(ωi )
p(x)
(16)
che è una scaled likelihood.
Se p(x) è nota, possiamo usare MLP per stimare la pdf. Inoltre: se
P(ωi ) dovesse cambiare durante il test rispetto al training,
′
passando al nuovo valore P (ωi ), possiamo ottenere la nuova stima
′
della class-posterior, ovvero P (ωi |x), senza dover fare nuovamente
il training del MLP, nel seguente modo:
′
P (ωi |x) =
yi (x) ′
p(x|ωi ) ′
P (ωi ) ≃
P (ωi )
p(x)
P(ωi )
(17)
Radial Basis Functions (RBF) Networks
Figura: RBF
yi =
k
X
wij ϕj (x) + wio
j=1
Nota: l’analogia con Parzen-Window. Nota: è un Generalized
Linear Discriminant.
(18)
La RBF (o kernel) ϕk (x) è:
−
ϕk (x) = e
kx−µk k2
2σ 2
k
(19)
RBF semplificata (degenere): un MLP con 1-hidden layer di
gaussiane e un output layer lineare.
Teorema di Universalità: le RBF sono approssimatori
universali.
P
Aprendimento (supervisionato): C (τ, w ) = 12 i (ybi − yi )2 .
Approccio 1: con discesa del gradiente di C (w ), si apprendono i
parametri wij , wio , µk e σk .
Approccio 2: si individuano µk e σk con tecniche di stima
statistica sullo spazio delle feature, successivamente si apprendono
i coefficienti delle trasformazioni lineari di output con tecniche
geometriche (inversione di matrici) o con gradient descent.
Nota: le RBF realizzano misture di pdf. Questo le rende
particolarmente adatte a modellare pdf.
Maximum-likelihood (ML) criterion: con RBF posso applicare
gradient-ascent per addestrare la ANNRsu ML per stimare pdf. Con
MLP no (MLP non rispetta il vincolo p(x)dx = 1).