RNN vanilla: stato nascosto e srotolamento della sequenza

Le reti standard feedforward trattano ogni input in modo indipendente: non conservano memoria degli input precedenti. Tuttavia, molti problemi del mondo reale coinvolgono dati sequenziali, nei quali il contesto passato è importante: prevedere la parola successiva di una frase, stimare il prezzo azionario di domani a partire dai dati storici o classificare un gesto da una sequenza di fotogrammi video. Le Recurrent Neural Networks (RNNs) risolvono questo problema mantenendo uno stato nascosto che trasporta le informazioni attraverso i diversi istanti temporali.

Una cella RNN vanilla riceve due input: l'input corrente x_t e lo stato nascosto precedente h_{t-1}. Produce lo stato nascosto successivo h_t usando la formula: h_t = tanh(W_hh * h_{t-1} + W_xh * x_t + b). Le stesse matrici dei pesi W_hh e W_xh vengono usate a ogni istante temporale: questa è la condivisione dei pesi nel tempo, analoga alla condivisione dei pesi nello spazio tipica delle CNN. Lo stato nascosto conserva la memoria della rete relativa a tutti gli input passati.

Per elaborare una sequenza di lunghezza T, la cella RNN viene applicata T volte in un ciclo: questa operazione è chiamata srotolamento (o unfolding) nel tempo. Lo stato nascosto del passo t-1 viene passato al passo t, collegando tutti gli istanti temporali. Durante la retropropagazione, i gradienti devono scorrere a ritroso attraverso ogni istante temporale: questa procedura è chiamata Backpropagation Through Time (BPTT). La profondità del grafo srotolato corrisponde alla lunghezza della sequenza, creando difficoltà per le sequenze lunghe.

nn.RNN gestisce automaticamente lo srotolamento. Riceve input con forma (seq_len, batch, input_size) oppure (batch, seq_len, input_size) con batch_first=True e restituisce tutti gli stati nascosti e lo stato nascosto finale. Parametri principali: num_layers impila più livelli RNN; bidirectional=True elabora la sequenza in entrambe le direzioni; dropout applica il dropout tra i livelli nelle RNN multilivello.

Lo stato nascosto iniziale h_0 viene passato come secondo argomento a nn.RNN. Se non viene fornito, viene impostato per impostazione predefinita a zero. Nella classificazione di sequenze, lo stato nascosto finale h_n riassume l'intera sequenza. Nei task sequence-to-sequence vengono usati tutti gli stati nascosti intermedi contenuti in output. Inizializzare h_0 a zero è lo standard; alcune applicazioni apprendono lo stato iniziale come parametro per migliorare le prestazioni sulle sequenze brevi.

Un'applicazione comune delle RNN è la classificazione di sequenze: data una sequenza, si predice un'unica etichetta di classe. L'approccio standard consiste nell'usare solo lo stato nascosto finale h_n come input per un classificatore lineare, poiché ha ricevuto l'intera sequenza fino a quel punto. In una RNN bidirezionale, si concatenano gli stati nascosti finali della direzione in avanti e di quella all'indietro per catturare sia il contesto passato sia quello futuro.

Nelle attività di etichettatura di sequenze (tagging POS, riconoscimento di entità nominate, rilevamento di anomalie nelle serie temporali), è necessaria una previsione a ogni passo temporale, non solo all'ultimo. Utilizzi l'intero tensore output di nn.RNN (forma: batch x seq_len x hidden_size) e applichi un livello lineare a ogni passo temporale in modo indipendente. I pesi del livello lineare sono condivisi tra i passi temporali: un altro esempio di condivisione dei pesi nei modelli sequenziali.

Le RNN impilate (num_layers > 1) forniscono l'output di un livello RNN come input al successivo, apprendendo rappresentazioni temporali progressivamente più astratte. Le RNN bidirezionali elaborano la sequenza simultaneamente in avanti (da sinistra a destra) e all'indietro (da destra a sinistra), quindi concatenano gli stati nascosti. L'elaborazione bidirezionale consente a ogni output di incorporare il contesto sia passato sia futuro, una caratteristica utile per comprendere le frasi, in cui le parole future chiariscono il significato di quelle precedenti.

La backpropagation attraverso il tempo srotola la RNN e applica la backpropagation standard al grafo srotolato. Per una sequenza di lunghezza T, i gradienti vengono calcolati a ogni passo temporale e propagati all'indietro. Il gradiente della loss rispetto ai parametri implica prodotti della stessa matrice dei pesi W_hh moltiplicata T volte. Quando il raggio spettrale di W_hh è minore di 1, questi prodotti svaniscono; quando è maggiore di 1, esplodono: questa è la difficoltà fondamentale nell'addestramento delle RNN su sequenze lunghe.

Nella pratica, le sequenze di un batch hanno lunghezze diverse, ad esempio frasi con un numero diverso di parole. PyTorch gestisce questo caso con le sequenze impacchettate: torch.nn.utils.rnn.pack_padded_sequence rimuove il padding da un batch e impacchetta le sequenze in modo efficiente. Dopo la RNN, pad_packed_sequence ripristina il formato con padding. Senza l'impacchettamento, la RNN elabora inutilmente i token di padding e può contaminare lo stato nascosto con informazioni prive di significato provenienti dal padding.

Le RNN vanilla sono usate raramente nella pratica perché soffrono gravemente del problema dei gradienti che svaniscono su sequenze più lunghe di 10-20 passi temporali. Sono utili soprattutto per scopi didattici e per sequenze molto brevi. Per qualsiasi applicazione reale con sequenze più lunghe di 20 passi temporali, utilizzi LSTM o GRU, dotate di meccanismi di gating progettati specificamente per preservare le informazioni su lunghe distanze. Per le sequenze in cui l'ordine è meno importante, le architetture Transformer spesso superano entrambe.

In questa lezione ha imparato che: le RNN vanilla mantengono uno stato nascosto che conserva la memoria tra i passi temporali usando la formula h_t = tanh(W_xh * x_t + W_hh * h_{t-1} + b), che lo srotolamento applica la stessa cella a ogni passo temporale con pesi condivisi e che la BPTT propaga i gradienti all'indietro attraverso il grafo srotolato, causando problemi di gradienti che svaniscono o esplodono nelle sequenze lunghe. Nel prossimo argomento esamineremo in dettaglio il problema dei gradienti che svaniscono e capiremo perché LSTM è stata progettata per risolverlo.