Pourquoi se propager dans le temps dans un RNN?

Dans un réseau de neurones récurrent, vous propagez généralement la propagation en plusieurs étapes, "déroulez" le réseau, puis la propagation en arrière sur la séquence d'entrées.

Pourquoi ne mettez-vous pas simplement à jour les poids après chaque étape individuelle de la séquence? (l'équivalent de l'utilisation d'une longueur de troncature de 1, il n'y a donc rien à dérouler) Cela élimine complètement le problème de gradient de fuite, simplifie considérablement l'algorithme, réduirait probablement les chances de rester coincé dans les minima locaux et, surtout, semble fonctionner correctement. . J'ai formé un modèle de cette façon pour générer du texte et les résultats semblaient comparables aux résultats que j'ai vus des modèles formés par BPTT. Je ne suis confus là-dessus que parce que chaque tutoriel sur les RNN que j'ai vu dit d'utiliser BPTT, presque comme s'il était nécessaire pour un apprentissage correct, ce qui n'est pas le cas.

Mise à jour: j'ai ajouté une réponse

Edit: J'ai fait une grosse erreur en comparant les deux méthodes et je dois changer ma réponse. Il s'avère que je le faisais, juste en se propageant sur le pas de temps actuel, commence réellement à apprendre plus rapidement. Les mises à jour rapides apprennent très rapidement les modèles les plus élémentaires. Mais sur un ensemble de données plus important et avec un temps de formation plus long, BPTT arrive en tête. Je testais un petit échantillon pour seulement quelques époques et je supposais que celui qui gagnerait la course serait le vainqueur. Mais cela m'a conduit à une découverte intéressante. Si vous commencez votre entraînement à se propager en un seul pas de temps, puis passez à BPTT et augmentez lentement la distance de propagation, vous obtenez une convergence plus rapide.

Un RNN est un réseau neuronal profond (DNN) où chaque couche peut prendre une nouvelle entrée mais avoir les mêmes paramètres. BPT est un mot fantaisie pour Back Propagation sur un tel réseau qui est lui-même un mot fantaisie pour Gradient Descent.

Dire que le RNN de y t dans chaque étape et 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}$$

Afin d'apprendre les poids, nous avons besoin de gradients pour que la fonction réponde à la question "dans quelle mesure un changement de paramètre affecte-t-il la fonction de perte?" et déplacer les paramètres dans la direction donnée par:

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

C'est-à-dire que nous avons un DNN où nous obtenons des commentaires sur la qualité de la prédiction à chaque couche. Puisqu'un changement de paramètre changera chaque couche dans le DNN (pas de temps) et chaque couche contribue aux sorties à venir, cela doit être pris en compte.

Prenez un simple réseau à une couche neurone pour voir ceci de manière semi-explicite:

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

Avec le taux d'apprentissage une étape d'apprentissage est alors: [ ~ a ~ b ~ c ] ← [ a b c ] + δ ( y t - y t ) ∇ y$\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}$$

$\nabla \hat{y}_{t+1}$$\nabla \hat{y}_{t}$$t$

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

Peut-être que chaque étape contribuera alors à une direction brute qui est suffisante en agrégation? Cela pourrait expliquer vos résultats, mais je serais vraiment intéressé d'en savoir plus sur votre méthode / fonction de perte! Serait également intéressé par une comparaison avec un ANN à deux fenêtres fenêtrées.

edit4: Après avoir lu les commentaires, il semble que votre architecture ne soit pas un RNN.

$h_t$

Votre modèle: sans état - état caché reconstruit à chaque étape edit2: ajout de références aux DNN edit3: correction de gradstep et quelques notations edit5: correction de l'interprétation de votre modèle après votre réponse / clarification.

"Déplier dans le temps" est simplement une application de la règle de la chaîne,

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

La sortie d'un RNN au pas de temps $t$, $H_t$ est fonction des paramètres $\theta$, l'entrée $x_t$ et l'état précédent, $H_{t-1}$ (notez qu'à la place $H_t$ peut être transformé à nouveau au pas de temps $t$pour obtenir la sortie, ce n'est pas important ici). Rappelez-vous l'objectif de la descente du gradient: étant donné une fonction d'erreur$L$, regardons notre erreur pour l'exemple (ou les exemples) en cours, puis ajustons $\theta$ de telle manière que, étant donné le même exemple, notre erreur serait réduite.

Comment exactement $\theta$contribuer à notre erreur actuelle? Nous avons pris une somme pondérée avec notre entrée actuelle,$x_t$, nous devons donc effectuer une rétropropagation via l'entrée pour trouver $\nabla_\theta a(x_t, \theta)$, pour savoir comment ajuster $\theta$. Mais notre erreur est aussi le résultat d'une contribution de$H_{t-1}$, qui était également fonction de $\theta$, droite? Nous devons donc découvrir$\nabla_\theta H_{t-1}$, qui était fonction de $x_{t-1}$, $\theta$ et $H_{t-2}$. Mais$H_{t-2}$ était également une fonction une fonction de $\theta$. Etc.