J'ai récemment appris comment un réseau neuronal vanille fonctionnerait, avec un nombre donné d'entrées, des nœuds cachés et le même nombre de sorties que les entrées.

J'ai regardé divers articles liés au réseau neuronal récurrent, et je comprends le concept derrière, mais je n'arrive pas à comprendre certaines parties de la logique derrière le RNN.

Voici quatre questions principales que j'ai:

1. Comment fonctionne la rétropropagation dans un réseau de neurones récurrent?
2. Les poids qui mènent de l'entrée aux nœuds cachés sont-ils les mêmes pour toutes les autres étapes? Qu'en est-il des poids des nœuds cachés aux sorties?
3. Comment les biais fonctionnent-ils exactement dans un réseau neuronal récurrent?
4. Pourquoi la fonction tanh est-elle généralement utilisée à la place de la fonction sigmoïde comme fonction d'activation?

Je me rends compte que certaines de ces questions sont très basiques, mais je suppose que les bases sont exactement ce dont j'ai besoin en ce moment.

Même les liens vers des vidéos ou des publications connexes seront extrêmement utiles, tout comme les mots clés Google qui affichent les bons résultats. Ces quatre questions m'empêchent de comprendre des exemples de codes Python, j'ai donc vraiment besoin d'aide.

Cette question concerne certaines qualités très importantes des RNN et des DNN en général. Je répondrai à chacune de vos sous-questions, mais pas dans le même ordre (je vais essayer de mettre en évidence où je fais)

Partage de paramètres

Premièrement, la qualité la plus importante des RNN est appelée partage de paramètres . Les données séquentielles sont généralement entrées dans des couches distinctes. Pour une entrée de longueur 20, un réseau RNN aurait 20 couches. Les mêmes paramètres internes sont utilisés pour chaque couche, donc les 20 couches utilisent les mêmes poids$W$ et biais $b$. Comparez cela à un perceptron multicouche qui aurait 20 poids et biais distincts.

Le partage de paramètres présente plusieurs avantages:

• Nous avons maintenant beaucoup moins de paramètres. Il y a 1 bloc répété au lieu de 20 couches distinctes. Une réduction de 20x!
• Cela multiplie efficacement les données d'entraînement. La couche récurrente apprend de chaque mot dans une seule phrase d'exemple tandis que chaque couche dans un MLP apprend d'un seul mot par phrase.
• Notre réseau est désormais beaucoup plus flexible. Nous pouvons nous entraîner sur des phrases jusqu'à 20 mots, puis généraliser à une phrase de 25 mots en ajoutant plus d'étapes ou en utilisant un RNN dynamique

Architecture de réseau

Vous posez des questions sur les activations tanh et sigmoïde. Pour répondre à cela, nous devons parler d'architectures RNN spécifiques. Le RNN simple discuté ci-dessus a une seule activation. Les RNN simples ont tendance à créer le problème de la disparition des gradients (ou de l'explosion!) En raison de l'application répétée des mêmes poids et de la même fonction d'activation.

Les blocs RNN déclenchés (comme les GRU et les LSTM) utilisent des mécanismes de déclenchement pour passer des activations dans et hors des états de la mémoire et pour combiner les états de la mémoire avec l'entrée pour générer la sortie de chaque bloc. Pour cette raison, les portes peuvent empêcher le gradient de se propager vers l'arrière. Sigmoid est une fonction d'activation courante pour les portes car elle écrase les activations à (0,1) --- 0 arrête complètement l'activation et 1 la laisse passer. Cependant, toute fonction d'activation décente avec un profil d'écrasement similaire fonctionne. Pour l'anecdote, la sigmoïde dure est assez courante de nos jours.

En plus des portes, les blocs RNN à portes ont un état interne pour lequel l'activation varie beaucoup. Parce que le Gating limite le backprop dégradé, nous avons beaucoup de flexibilité sur cette activation. Il n'est pas nécessaire qu'il écrase par exemple, et c'est là que les activations de rectification (relu, elu, islu, etc.) sont souvent vues. Tanh est également un choix parfaitement judicieux.

En ce qui concerne les biais et les poids, chaque activation dans une cellule RNN a généralement son propre poids et biais. Ainsi, un GRU a 3 activations (caché, mise à jour et réinitialisation) et chacune a son propre poids et biais. Cependant, rappelez-vous qu'en tant que RNN, chacun d'eux est réutilisé pour chaque pas de temps.

Passe arrière

Cela couvre assez bien la passe avant, mais vous posez également une question importante sur la façon dont l'erreur se propage vers l'arrière. Il existe deux méthodes pour aborder cela.

Forcer l'enseignant

Pour les RNN qui produisent une prédiction à chaque pas de temps (comme prédire le résultat des étapes suivantes, la traduction ou la reconnaissance des phonèmes), le forçage par l'enseignant est une méthode pour isoler chaque étape du RNN. En supprimant ces dépendances, Teacher Forcing permet à RNN d'utiliser un backprop conventionnel avec la règle de chaîne.

Mais comment ça fonctionne? Les réseaux de forçage des enseignants ont des architectures de train et de test distinctes. Pour la formation, à chaque pas de temps$t$, l'entrée $x_t$ est concaténé avec la cible précédente, $y_{t-1}$. Imaginez ceci pour un réseau chargé de prédire le caractère suivant. Le réseau vient d'essayer de prédire le caractère du pas de temps précédent. Mais nous utilisons plutôt le personnage observé à ce pas de temps (nous le savons parce que nous sommes dans la phase d'entraînement). Ainsi l'erreur au pas de temps$t$ ne dépend que de la valeur observée à $t-1$ et l'entrée à $t$. Nous avons donc supprimé toutes les connexions dans le temps du réseau.

Au test, nous ne connaissons pas la vraie valeur à chaque pas de temps donc nous remplaçons $y_{t-1}$ avec la sortie de la couche précédente $o_{t-1}$. Dans ce cas, les connexions temporelles sont revenues mais uniquement pour la phase de test.

Propagation arrière à travers le temps

Mais nous ne devons recourir à l' enseignant Forcing. La rétro-propagation dans le temps nous permet d'appliquer l'algorithme de backprop aux RNN. Considérez le réseau avec$n$ pas de temps et une entrée $x$, état caché $h$, production $o$et valeur observée $y$ pour chaque pas de temps.

BPTT fonctionne dans les étapes suivantes.

1. Calculez le gradient $\nabla_{o_t}$ pour chaque $o_t, y_t$paire. (Cela peut être fait en une seule fois.)
2. Calculez le gradient $\nabla_{h_t}$pour chaque pas de temps, en commençant par le dernier pas de temps et en travaillant itérativement en arrière. (Cela doit être fait un à la fois.)
3. Cela nous donne $n$ bords pour chaque paramètre interne de notre RNN. L'astuce pour mettre à jour les paramètres est de trouver la contribution du gradient pour chaque pas de temps (par ex.$\nabla_{W_t}$ même si nous n'en avons qu'un $W$), puis en additionnant ces gradients pour mettre à jour les paramètres internes.

Lectures complémentaires

Je recommande fortement le chapitre 10 de Goodfellow, Bengio et Deep Learning de Courville pour plus d'informations sur les RNN. De plus, le livre RNN de Graves est fantastique pour des détails de plus haut niveau