Dlaczego wstecz propaguje się w czasie w sieci RNN?

W nawracającej sieci neuronowej zwykle propagujesz w przód przez kilka kroków czasowych, „rozwijasz” sieć, a następnie w tył propagujesz w sekwencji danych wejściowych.

Dlaczego po prostu nie aktualizowałbyś wag po każdym indywidualnym kroku w sekwencji? (odpowiednik użycia długości obcięcia 1, więc nie ma nic do rozwinięcia) To całkowicie eliminuje problem znikającego gradientu, znacznie upraszcza algorytm, prawdopodobnie zmniejszy szanse utknięcia w lokalnych minimach i, co najważniejsze, wydaje się działać dobrze . Trenowałem w ten sposób model do generowania tekstu, a wyniki wydawały się porównywalne z wynikami, które widziałem w modelach przeszkolonych przez BPTT. Jestem tylko zdezorientowany, ponieważ każdy samouczek na temat RNN, które widziałem, mówi o używaniu BPTT, prawie tak, jakby był wymagany do prawidłowego uczenia się, co nie jest prawdą.

Aktualizacja: dodałem odpowiedź

Edycja: Popełniłem duży błąd podczas porównywania dwóch metod i musiałem zmienić swoją odpowiedź. Okazuje się, że tak to robiłem, po prostu propagując bieżący krok czasu, faktycznie zaczyna się szybciej uczyć. Szybkie aktualizacje bardzo szybko uczą się najbardziej podstawowych wzorców. Ale w przypadku większego zestawu danych i dłuższego czasu szkolenia BPTT faktycznie wychodzi na prowadzenie. Testowałem małą próbkę przez kilka epok i założyłem, że ktokolwiek zacznie wygrywać wyścig, będzie zwycięzcą. Ale to doprowadziło mnie do interesującego znaleziska. Jeśli zaczniesz trenować z powrotem propagując tylko jeden krok czasowy, następnie zmień na BPTT i powoli zwiększaj, jak daleko się propagujesz, uzyskasz szybszą konwergencję.

RNN to Deep Neural Network (DNN), gdzie każda warstwa może przyjmować nowe dane wejściowe, ale ma te same parametry. BPT jest fantazyjnym słowem dla propagacji wstecznej w takiej sieci, która sama w sobie jest fantazyjnym słowem dla Gradient Descent.

Załóżmy, że w RNN WYJŚCIA y t w każdym etapie i e r r o r t = ( y t - r t ) 2$\hat{y}_t$

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

Aby poznać wagi, potrzebujemy gradientów, aby funkcja mogła odpowiedzieć na pytanie „jak bardzo zmiana parametru wpływa na funkcję straty?” i przesuń parametry w kierunku podanym przez:

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

To znaczy, mamy DNN, gdzie otrzymujemy informację zwrotną o tym, jak dobre są prognozy dla każdej warstwy. Ponieważ zmiana parametru zmieni każdą warstwę w DNN (timestep), a każda warstwa przyczynia się do nadchodzących wyników, należy to uwzględnić.

Weź prostą sieć z jedną warstwą jeden neuron, aby zobaczyć to częściowo jawnie:

$$\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*}$$

With $\delta$ the learning rate one training step is then:

$$\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.