Dimentica il livello in una rete neurale ricorrente (RNN) -

Sto cercando di capire le dimensioni di ciascuna variabile in un RNN nel livello di dimenticanza, tuttavia, non sono sicuro di essere sulla strada giusta. L'immagine e l'equazione successive sono tratte dal post sul blog di Colah "Capire le reti LSTM" :

dove:

• $x_t$ è un input di dimensione vettore$m*1$
• $h_{t-1}$ è lo stato nascosto della dimensione vettore$n*1$
• $[x_t, h_{t-1}]$ è una concatenazione (ad esempio, se , quindi )$x_t=[1, 2, 3], h_{t-1}=[4, 5, 6]$$[x_t, h_{t-1}]=[1, 2, 3, 4, 5, 6]$
• $w_f$ è pesi di dimensione matrice, dove è il numero di stati di cella (se , e nell'esempio precedente e se abbiamo 3 stati di cella, allora matrice)$k*(m+n)$$k$$m=3$$n=3$$w_f=3*3$
• $b_f$ è un bias di dimensione vettore, dove è il numero di stati di cella (poiché come nell'esempio precedente, allora è un vettore ).$k*1$$k$$k=3$$b_f$$3*1$

Se impostiamo su: $w_f$

E essere:$b_f$$[1, 2, 3]$

Quindi$W_f . [h_{t-1}, x_t] =$

Quindi possiamo aggiungere il bias,$W_f . [h_{t-1}, x_t] + b_f=$

Quindi li inseriamo in una funzione sigmoide: , dove , quindi eseguiamo questo elemento funzione saggio e ottieni .$\frac{1}{1+e^{-x}}$$x=\begin{bmatrix} 92 & 177 & 136\end{bmatrix}$

Il che significa per ogni stato di cella, , (ci sono stati di cella), gli permettiamo di passare al livello successivo.$C_{t-1}$$k=3$

L'assunzione di cui sopra è corretta?

Questo significa anche che il numero di stato delle celle e stato nascosto è lo stesso?

Ottima domanda!

tl; dr: lo stato della cella e lo stato nascosto sono due cose diverse, ma lo stato nascosto dipende dallo stato della cella e hanno effettivamente le stesse dimensioni.

Spiegazione più lunga

La differenza tra i due può essere vista dallo schema seguente (parte dello stesso blog):

Lo stato della cella è la linea in grassetto che viaggia da ovest a est attraverso la cima. L'intero blocco verde è chiamato "cellula".

Lo stato nascosto della fase temporale precedente viene trattato come parte dell'input nella fase temporale corrente.

Tuttavia, è un po 'più difficile vedere la dipendenza tra i due senza fare una passeggiata completa. Lo farò qui, per fornire un'altra prospettiva, ma fortemente influenzato dal blog. La mia notazione sarà la stessa e userò le immagini del blog nella mia spiegazione.

Mi piace pensare all'ordine delle operazioni in modo leggermente diverso dal modo in cui sono state presentate nel blog. Personalmente, come partire dal gate di input. Presenterò questo punto di vista qui sotto, ma tieni presente che il blog potrebbe benissimo essere il modo migliore per impostare un LSTM a livello computazionale e questa spiegazione è puramente concettuale.

Ecco cosa sta succedendo:

La porta d'ingresso

L'input al momento è e . Questi vengono concatenati e alimentati in una funzione non lineare (in questo caso un sigmoide). Questa funzione sigmoide si chiama "input gate", perché funge da stopgap per l'ingresso. Decide stocasticamente quali valori aggiorneremo in questo momento, in base all'input corrente.$t$$x_t$$h_{t-1}$

Cioè, (seguendo il tuo esempio), se abbiamo un vettore di input e uno stato nascosto precedente , allora il gate di ingresso fa quanto segue:$x_t = [1, 2, 3]$$h_t = [4, 5, 6]$

a) Concatenare e per darci$x_t$$h_{t-1}$$[1, 2, 3, 4, 5, 6]$

b) Calcola volte il vettore concatenato e aggiungi il bias (in matematica: , dove è la matrice di peso dal vettore di input alla non linearità; è l'input bias).$W_i$$W_i \cdot [x_t, h_{t-1}] + b_i$$W_i$$b_i$

Supponiamo di passare da un input a sei dimensioni (la lunghezza del vettore di input concatenato) a una decisione tridimensionale su quali stati aggiornare. Ciò significa che abbiamo bisogno di una matrice di peso 3x6 e di un vettore di polarizzazione 3x1. Diamo alcuni valori:

$W_i = \begin{bmatrix} 1 & 1 & 1 & 1 & 1 & 1 \\ 2 & 2 & 2 & 2 & 2 & 2 \\ 3 & 3 & 3 & 3 & 3 & 3\end{bmatrix}$

$b_i = \begin{bmatrix} 1 \\ 1 \\ 1 \end{bmatrix}$

Il calcolo sarebbe:

$\begin{bmatrix} 1 & 1 & 1 & 1 & 1 & 1 \\ 2 & 2 & 2 & 2 & 2 & 2 \\ 3 & 3 & 3 & 3 & 3 & 3\end{bmatrix} \cdot \begin{bmatrix} 1 \\ 2 \\ 3 \\ 4 \\5 \\6 \end{bmatrix} + \begin{bmatrix} 1 \\ 1 \\ 1 \end{bmatrix} = \begin{bmatrix} 22 \\ 42 \\ 62 \end{bmatrix}$

c) Alimenta il calcolo precedente in una non linearità:$i_t = \sigma (W_i \cdot [x_t, h_{t-1}] + b_i)$

$\sigma(x) = \frac{1}{1 + exp(-x)}$ (lo applichiamo elementally ai valori nel vettore )$x$

$\sigma(\begin{bmatrix} 22 \\ 42 \\ 62 \end{bmatrix}) = [\frac{1}{1 + exp(-22)}, \frac{1}{1 + exp(-42)}, \frac{1}{1 + exp(-62)}] = [1, 1, 1]$

In inglese, ciò significa che aggiorneremo tutti i nostri stati.

Il gate di ingresso ha una seconda parte:

d)$\tilde{C_t} = tanh(W_C[x_t, h_{t-1}] + b_C)$

Il punto di questa parte è calcolare come aggiorneremmo lo stato, se dovessimo farlo. È il contributo del nuovo input in questo momento allo stato della cella. Il calcolo segue la stessa procedura illustrata sopra, ma con un'unità tanh anziché un'unità sigmoidea.

L'output viene moltiplicato per quel vettore binario , ma lo quando arriveremo all'aggiornamento della cella.$\tilde{C_t}$$i_t$

Insieme, ci dice quali stati vogliamo aggiornare e ci dice come vogliamo aggiornarli. Ci dice quali nuove informazioni vogliamo aggiungere alla nostra rappresentazione finora.$i_t$$\tilde{C_t}$

Poi arriva la porta dell'oblio, che era il nocciolo della tua domanda.

La porta dell'oblio

Lo scopo del cancello di dimenticanza è di rimuovere le informazioni apprese in precedenza che non sono più pertinenti. L'esempio fornito nel blog è basato sul linguaggio, ma possiamo anche pensare a una finestra scorrevole. Se stai modellando una serie temporale che è naturalmente rappresentata da numeri interi, come il conteggio di individui infetti in un'area durante un'epidemia, forse una volta che la malattia si è estinta in un'area, non vorrai più preoccuparti di considerare quell'area quando pensando a come la malattia viaggerà dopo.

Proprio come il livello di input, il livello di dimenticanza prende lo stato nascosto dal passaggio temporale precedente e il nuovo input dal passaggio temporale corrente e li concatena. Il punto è decidere stocasticamente cosa dimenticare e cosa ricordare. Nel calcolo precedente, ho mostrato un output di livello sigmoideo di tutti gli 1, ma in realtà era più vicino a 0,999 e ho arrotondato per eccesso.

Il calcolo è molto simile a quello che abbiamo fatto nel livello di input:

$f_t = \sigma(W_f [x_t, h_{t-1}] + b_f)$

Questo ci darà un vettore di dimensione 3 con valori compresi tra 0 e 1. Facciamo finta che ci abbia dato:

$[0.5, 0.8, 0.9]$

Quindi decidiamo stocasticamente in base a questi valori quali di queste tre parti di informazioni dimenticare. Un modo per fare ciò è generare un numero da una distribuzione uniforme (0, 1) e se quel numero è inferiore alla probabilità che l'unità si accenda (0,5, 0,8 e 0,9 per le unità 1, 2 e 3 rispettivamente), quindi accendiamo quell'unità. In questo caso, ciò significherebbe che dimenticheremo tali informazioni.

Nota rapida: il livello di input e il livello di dimenticanza sono indipendenti. Se fossi un giocatore di scommesse, scommetterei che è un buon posto per la parallelizzazione.

Aggiornamento dello stato della cella

Ora abbiamo tutto ciò che serve per aggiornare lo stato della cella. Prendiamo una combinazione delle informazioni dall'ingresso e dalle porte di dimenticanza:

$C_t = f_t \circ C_{t-1} + i_t \circ \tilde{C_t}$

Ora, sarà un po 'strano. Invece di moltiplicarsi come abbiamo fatto prima, qui indica il prodotto Hadamard, che è un prodotto entry-saggio.$\circ$

A parte: prodotto Hadamard

Ad esempio, se avessimo due vettori e e volessimo prendere il prodotto Hadamard, faremmo questo:$x_1 = [1, 2, 3]$$x_2 = [3, 2, 1]$

$x_1 \circ x_2 = [(1 \cdot 3), (2 \cdot 2), (3 \cdot 1)] = [3, 4, 3]$

Fine a parte.

In questo modo, uniamo ciò che vogliamo aggiungere allo stato della cella (input) con ciò che vogliamo togliere dallo stato della cella (dimentica). Il risultato è il nuovo stato della cella.

La porta di uscita

Questo ci darà il nuovo stato nascosto. Essenzialmente il punto del gate di uscita è decidere quali informazioni vogliamo che la parte successiva del modello prenda in considerazione quando si aggiorna il successivo stato di cella. L'esempio nel blog è di nuovo, la lingua: se il sostantivo è plurale, la coniugazione del verbo nel passaggio successivo cambierà. In un modello patologico, se la suscettibilità degli individui in una determinata area è diversa rispetto a un'altra, la probabilità di contrarre un'infezione può cambiare.

Il livello di output accetta di nuovo lo stesso input, ma considera quindi lo stato della cella aggiornato:

$o_t = \sigma(W_o [x_t, h_{t-1}] + b_o)$

Ancora una volta, questo ci dà un vettore di probabilità. Quindi calcoliamo:

$h_t = o_t \circ tanh(C_t)$

Quindi lo stato attuale della cella e la porta di uscita devono concordare su cosa emettere.

Cioè, se il risultato di è dopo che è stata presa la decisione stocastica se ciascuna unità è accesa o spenta e il risultato di è , quindi quando prendiamo il prodotto Hadamard, otterremo e solo le unità che sono state accese sia dal gate di uscita che nello stato della cella faranno parte dell'output finale.$tanh(C_t)$$[0, 1, 1]$$o_t$$[0, 0, 1]$$[0, 0, 1]$

[EDIT: C'è un commento sul blog che dice che viene nuovamente trasformato in un output effettivo di , il che significa che l'output effettivo sullo schermo (supponendo che tu ne abbia alcuni) è il risultato di un'altra trasformazione non lineare.]$h_t$$y_t = \sigma(W \cdot h_t)$

Il diagramma mostra che va in due posizioni: la cella successiva e "output" - sullo schermo. Penso che la seconda parte sia facoltativa.$h_t$

Ci sono molte varianti su LSTM, ma questo copre l'essenziale!