Perché indietro propagarsi nel tempo in un RNN?

In una rete neurale ricorrente, di solito si inoltra la propagazione attraverso diversi passaggi temporali, "si srotolano" la rete e quindi si propagano indietro attraverso la sequenza di input.

Perché non dovresti semplicemente aggiornare i pesi dopo ogni singolo passaggio della sequenza? (l'equivalente dell'uso di una lunghezza di troncamento di 1, quindi non c'è nulla da srotolare) Questo elimina completamente il problema del gradiente di fuga, semplifica notevolmente l'algoritmo, probabilmente ridurrebbe le possibilità di rimanere bloccati nei minimi locali e, soprattutto, sembra funzionare bene . Ho formato un modello in questo modo per generare testo e i risultati sembravano paragonabili ai risultati che ho visto dai modelli addestrati BPTT. Sono confuso solo su questo perché ogni tutorial su RNN che ho visto dice di usare BPTT, quasi come se fosse necessario per un corretto apprendimento, il che non è il caso.

Aggiornamento: ho aggiunto una risposta

Modifica: ho fatto un grosso errore nel confrontare i due metodi e devo cambiare la mia risposta. Si scopre il modo in cui lo stavo facendo, appena tornato a propagarsi sull'attuale fase temporale, in realtà inizia a imparare più velocemente. I rapidi aggiornamenti apprendono molto rapidamente gli schemi più elementari. Ma su un set di dati più ampio e con tempi di allenamento più lunghi, BPTT risulta di fatto al top. Stavo testando un piccolo campione per poche epoche e ho pensato che chiunque avesse iniziato a vincere la gara sarebbe stato il vincitore. Ma questo mi ha portato a una scoperta interessante. Se inizi l'addestramento indietro propagandoti solo un singolo passaggio temporale, poi passa a BPTT e aumenti lentamente la distanza di propagazione, otterrai una convergenza più rapida.

Un RNN è una rete neurale profonda (DNN) in cui ogni livello può ricevere un nuovo input ma avere gli stessi parametri. BPT è una parola di fantasia per Back Propagation su tale rete che è essa stessa una parola di fantasia per Discesa a Gradiente.

Dire che il RNN uscite y t in ogni passo e e r r o r t = ( y t - y t ) 2$\hat{y}_t$

$$\begin{equation} error_t=(y_t-\hat{y}_t)^2 \end{equation}$$

Per apprendere i pesi abbiamo bisogno di gradienti affinché la funzione risponda alla domanda "quanto un cambiamento nel parametro ha effetto sulla funzione di perdita?" e spostare i parametri nella direzione indicata da:

$$\begin{equation} \nabla error_t=-2(y_t-\hat{y}_t)\nabla \hat{y}_t \end{equation}$$

Cioè abbiamo un DNN in cui riceviamo feedback su quanto sia buona la previsione su ogni livello. Dal momento che una modifica del parametro cambierà ogni livello nel DNN (timestep) e ogni livello contribuirà agli output imminenti che devono essere tenuti in considerazione.

Prendi una semplice rete di un neurone-uno strato per vederlo semi-esplicitamente:

$$\begin{align*} \hat{y}_{t+1} =& f(a+bx_t+c\hat{y}_t)\\ \frac{\partial}{\partial a}\hat{y}_{t+1} = & f'(a+bx_t+c\hat{y}_t)\cdot c\cdot \frac{\partial}{\partial a}\hat{y}_{t} \\ \frac{\partial}{\partial b}\hat{y}_{t+1} = & f'(a+bx_t+c\hat{y}_t)\cdot (x_t+c\cdot\frac{\partial}{\partial b}\hat{y}_{t})\\ \frac{\partial}{\partial c}\hat{y}_{t+1} = & f'(a+bx_t+c\hat{y}_t)\cdot (\hat{y}_t+c\cdot\frac{\partial}{\partial c}\hat{y}_{t})\\ \iff\\ \nabla \hat{y}_{t+1} =& f'(a+bx_t+c\hat{y}_t)\cdot \left(\begin{bmatrix}0\\x_t\\\hat{y}_t \end{bmatrix} + c \mathbin{\color{red}{\nabla \hat{y}_{t}}} \right) \end{align*}$$

$\delta$

$$\begin{equation} \begin{bmatrix}\tilde{a}\\\tilde{b}\\\tilde{c}\end{bmatrix} \leftarrow \begin{bmatrix}a\\b\\c\end{bmatrix} + \delta (y_{t}-\hat{y}_{t})\nabla \hat{y}_t \end{equation}$$

What we see is that in order to calculate $\nabla \hat{y}_{t+1}$ you need to calculate i.e roll out $\nabla \hat{y}_{t}$. What you propose is to simply disregard the red part calculate the red part for $t$ but not recurse further. I assume that your loss is something like

$$\begin{equation} error=\sum_t(y_t-\hat{y}_t)^2 \end{equation}$$

Maybe each step will then contribute a crude direction which is enough in aggregation? This could explain your results but I'd be really interested in hearing more about your method/loss function! Also would be interested in a comparison with a two timestep windowed ANN.

edit4: After reading comments it seems like your architecture is not an RNN.

RNN: Stateful - carry forward hidden state $h_t$ indefinitely This is your model but the training is different.

Your model: Stateless - hidden state rebuilt in each step edit2 : added more refs to DNNs edit3 : fixed gradstep and some notation edit5 : Fixed the interpretation of your model after your answer/clarification.

"Unfolding through time" is simply an application of the chain rule,

$$\frac{dF(g(x), h(x), m(x))}{dx} = \frac{\partial F}{\partial g}\frac{dg}{dx} + \frac{\partial F}{\partial h}\frac{dh}{dx} + \frac{\partial F}{\partial m}\frac{dm}{dx}$$

The output of an RNN at time step $t$, $H_t$ is a function of the parameters $\theta$, the input $x_t$ and the previous state, $H_{t-1}$ (note that instead $H_t$ may be transformed again at time step $t$ to obtain the output, that is not important here). Remember the goal of gradient descent: given some error function $L$, let's look at our error for the current example (or examples), and then let's adjust $\theta$ in such a way, that given the same example again, our error would be reduced.

How exactly did $\theta$ contribute to our current error? We took a weighted sum with our current input, $x_t$, so we'll need to backpropagate through the input to find $\nabla_\theta a(x_t, \theta)$, to work out how to adjust $\theta$. But our error was also the result of some contribution from $H_{t-1}$, which was also a function of $\theta$, right? So we need to find out $\nabla_\theta H_{t-1}$, which was a function of $x_{t-1}$, $\theta$ and $H_{t-2}$. But $H_{t-2}$ was also a function a function of $\theta$. And so on.