imported>Rosa Olmos: /* Pseudocode */ def -> function

2025-07-05T12:46:44Z

Pseudocode: def -> function

Neue Seite

Als '''rekurrente''' bzw. '''rückgekoppelte neuronale Netze''' bezeichnet man [[Neuronales Netz|neuronale Netze]], die sich im Gegensatz zu den [[Künstliches Neuron|Feedforward-Netzen]] durch Verbindungen von [[Nervenzelle|Neuronen]] einer Schicht zu Neuronen derselben oder einer vorangegangenen Schicht auszeichnen. Im [[Gehirn]] ist dies die bevorzugte Verschaltungsweise neuronaler Netze, insbesondere im [[Neocortex]]. In [[künstliches neuronales Netz|künstlichen neuronalen Netzen]] wird die rekurrente Verschaltung von [[künstliches Neuron|Modellneuronen]] benutzt, um zeitlich codierte Informationen in den Daten zu entdecken.<ref name="kruse-online" /><ref name="kruse-print" /> Beispiele für solche rekurrenten neuronalen Netze sind das [[Elman-Netz]], das [[Jordan-Netz]], das [[Hopfield-Netz]] sowie das vollständig verbundene neuronale Netz.

[[Datei:Neuronal-Networks-Feedback.png|mini|Verschiedene Arten von Rückkopplungen: Die blaue Kante (<math>w_d</math>) ist eine direkte, die grüne (<math>w_i</math>) eine indirekte und die rote (<math>w_l</math>) eine seitliche Rückkopplung.]]

== Eigenschaften ==
Ein rekurrentes neuronales Netz hat ein Gedächtnis, weil es Informationen aus früheren Eingaben verwendet, um die aktuelle Eingabe und Ausgabe zu beeinflussen. Während traditionelle tiefe neuronale Netze davon ausgehen, dass Eingaben und Ausgaben voneinander unabhängig sind, hängt die Ausgabe rekurrenter neuronaler Netze von den vorherigen Elementen innerhalb der Sequenz ab. Während zukünftige Ereignisse auch bei der Bestimmung der Ausgabe einer bestimmten Sequenz hilfreich wären, können unidirektionale rekurrente neuronale Netze diese Ereignisse nicht in ihren Vorhersagen berücksichtigen.

Ein weiteres Merkmal von rekurrenten Netzen besteht darin, dass sie Parameter über alle Schichten des Netzes hinweg gemeinsam nutzen. Während Feedforward-Netze über jeden Knoten unterschiedliche Gewichtungen haben, teilen sich rekurrente neuronale Netze innerhalb jeder Schicht denselben Gewichtungsparameter. Allerdings werden diese Gewichtungen immer noch durch die Prozesse der [[Backpropagation]] und des [[Gradientenabstiegsverfahren|Gradientenabstiegs]] angepasst, um das [[Bestärkendes Lernen|bestärkende Lernen]] zu erleichtern.<ref>IBM: [https://www.ibm.com/topics/recurrent-neural-networks What are recurrent neural networks?]</ref>

== Typen von rekurrenten neuronalen Netzen ==
Rekurrente Netze lassen sich folgendermaßen unterteilen:
* Bei einer direkten Rückkopplung ({{enS|direct feedback}}) wird der eigene Ausgang eines Neurons als weiterer Eingang genutzt.
* Die indirekte Rückkopplung ({{enS|indirect feedback}}) verbindet den Ausgang eines Neurons mit einem Neuron der vorhergehenden Schichten.
* Die seitliche Rückkopplung ({{enS|lateral feedback}}) verbindet den Ausgang eines Neurons mit einem anderen Neuron derselben Schicht.
* Bei einer vollständigen Verbindung hat jeder Neuronenausgang eine Verbindung zu jedem anderen Neuron.
Praktische Anwendung finden rekurrente neuronale Netze bei Problemstellungen, die das Verarbeiten von Sequenzen erfordern. Beispiele dafür sind [[Handschrifterkennung]], [[Spracherkennung]] und [[Maschinenübersetzung]]. Die hierbei vorherrschende Art der rekurrenten neuronalen Netze sind [[Long short-term memory|LSTMs]] beziehungsweise ähnliche Varianten, die auf einer direkten Rückkopplung basieren.

Die Implementierung von Rekurrenten neuronalen Netzen kann in gängigen Programmbibliotheken wie [[PyTorch]] bequem in Python erfolgen und dann mit [[Just-in-time-Kompilierung]] in effizienten Code übersetzt werden.

=== Elman-Netz ===
Ein [[Elman-Netz]] ist ein einfaches rekurrentes [[künstliches neuronales Netz]], das durch vorhandene [[Rückkopplung]]en von [[Kante (Graphentheorie)|Kanten]] zwischen den [[Künstliches Neuron|künstlichen Neuronen]] in der Lage ist, zeitliche Abhängigkeiten von Eingaben implizit zu verarbeiten. Benannt ist diese Netz-Architektur nach [[Jeffrey L. Elman]], der diese Struktur [[1990]] vorschlug.

Ein Elman-Netzwerk ist ein dreischichtiges neuronales Netz, dem man eine Menge von Kontexteinheiten hinzufügen kann. Die mittlere verborgene Schicht ist mit diesen Kontexteinheiten fest mit einer Gewichtung von 1 verbunden. Bei jedem Zeitschritt wird die Eingabe weitergeleitet und eine Lernregel angewendet. Die festen Rückverbindungen speichern eine Kopie der vorherigen Werte der versteckten Einheiten in den Kontexteinheiten, weil sie sich über die Verbindungen ausbreiten, bevor die Lernregel angewendet wird. Somit kann das Netzwerk eine Art Zustand aufrechterhalten, der es ihm ermöglicht, Aufgaben wie die Sequenzvorhersage auszuführen, die über die Leistungsfähigkeit eines standardmäßigen [[mehrlagiges Perzeptron]] hinausgehen.

Das System hat eine Eingangsschicht, eine verborgene Schicht und eine Ausgangsschicht, die alle in einer Feedforward-Weise verbunden sind. Die verborgene Schicht ist jedoch nicht nur mit der Ausgangsschicht verbunden, sondern in einer einfachen 1:1-Verbindung auch mit einer weiteren Schicht, der so genannten Kontextschicht. Um wiederkehrende Verbindungen zu bilden, wird die Ausgabe dieser Kontextschicht auch in die verborgene Schicht eingegeben. Mit Ausnahme dieser 1:1-Verbindungen von der verborgenen zur Kontextschicht, deren Gewichte auf 1 festgelegt sind, können alle anderen Schichten vollständig verbunden und alle Gewichte modifizierbar sein. Die wiederkehrenden Verbindungen der Kontextschicht stellen dem System ein Kurzzeitgedächtnis zur Verfügung. Die versteckten Einheiten beobachten nicht nur die eigentliche Eingabe, sondern erhalten über die Kontextschicht auch Informationen über ihren eigenen Zustand im letzten Zeitschritt. Da zu einem bestimmten Zeitschritt verborgene Einheiten bereits durch Eingaben in früheren Zeitschritten beeinflusst wurden, umfasst diese Wiederholung eine Erinnerung, die von früheren Zuständen abhängt, obwohl ihr Einfluss mit der Zeit abnimmt. Während des Betriebs wird der Eingang des Elman-Netzes mit einer zeitlichen Folge von Eingangsvektoren versehen. Um die Gewichte zu ändern, kann die Ausgabe mit einem gewünschten Ausgabevektor verglichen werden, und zum Beispiel kann die verallgemeinerte [[Delta-Regel]] angewendet werden, um die Gewichte zu ändern. Dadurch lernt das System, eine Ausgabe nicht nur direkt der Eingabe zuzuordnen, sondern auch der zeitlichen Abfolge mehrerer aufeinanderfolgender Eingabevektoren.<ref>Holk Cruse: [https://www.brains-minds-media.org/archive/615/bmm615.pdf Neural Networks as Cybernetic Systems]</ref>

=== Jordan-Netz ===
[[Jordan-Netz]]e ähneln Elman-Netze. Die Kontexteinheiten werden von der Ausgangsschicht anstatt von der verborgenen Schicht gespeist. Die Kontexteinheiten in einem Jordan-Netz werden auch als Zustandsschicht bezeichnet. Sie haben eine wiederkehrende Verbindung zu sich selbst. Elman-Netze und Jordan-Netze sind auch als einfache rekurrente Netze bekannt.

== Pseudocode ==
Gegeben sei eine Zeitreihe <code>x</code> der Länge <code>sequence_length</code>.
Im rekurrenten neuronalen Netz gibt es eine Schleife, welche nacheinander alle Einträge der Zeitreihe <code>x</code> durch die Schichten <code>neural_network</code> verarbeitet. Diese haben als Rückgabewert in jedem Zeitschritt <code>i</code> sowohl die Vorhersage <code>y_pred[i]</code> als auch einen aktualisierten verdeckten Zustand <code>hidden</code>, welcher die Länge <code>hidden_size</code> hat. Als Resultat nach der Schleife wird die Sammlung aller Vorhersagen <code>y_pred</code> zurückgegeben.
Der folgende Pseudocode (angelehnt an die Programmiersprache [[Python (Programmiersprache)|Python]]) illustriert die Funktionsweise eines rekurrenten neuronalen Netzes.<ref>Francois Chollet, Tomasz Kalinowski, J. J. Allaire: ''Deep Learning with R.'' 2. Auflage. Verlag Simon and Schuster, 2022, ISBN 978-1-63343-984-9, S. 451 [https://books.google.de/books?id=5l56EAAAQBAJ&pg=PT451 (books.google.de)]</ref>
::
<syntaxhighlight lang="python">
function RNN_forward(x, sequence_length, neural_network, hidden_size):
# Initialisiere Hidden State mit Nullen und Ausgabearray
hidden = zeros(size=hidden_size)
y_pred = zeros(size=sequence_length)

for i in range(sequence_length):
# Rufe RNN-Modell für einen Zeitschritt auf:
# Verarbeite x[i] mit aktuellem Hidden State
# Erhalte y_pred[i] und aktualisierten Hidden State
y_pred[i], hidden = neural_network(x[i], hidden)

return y_pred
</syntaxhighlight>
Moderne Bibliotheken liefern laufzeitoptimierte Implementierungen der obigen Funktionalität oder erlauben die langsame Schleife durch [[Just-in-time-Kompilierung]] stark zu beschleunigen.

== Trainieren von rekurrenten neuronalen Netzen ==
Das Trainieren eines typischen rekurrenten neuronalen Netzes umfasst folgende Schritte:

* Ein Beispiel aus einem Datensatz wird eingegeben.
* Das Netz nimmt dieses Beispiel auf und wendet einige komplexe Berechnungen mit zufällig initialisierten Variablen an.
* Ein vorhergesagtes Ergebnis wird produziert.
* Der Vergleich dieses Ergebnis mit dem erwarteten Wert ergibt einen Fehler.
* Wenn sich der Fehler durch denselben Pfad wieder ausbreitet, werden die Variablen angepasst.
* Die Schritte werden wiederholt, bis die Variablen gut definiert sind.

Der Unterschied zu einem Feedforward-Netz ergibt sich aus der Tatsache, dass vor der Bewertung des Ergebnisses auch die vorherigen Eingaben bekannt sind. Rekurrente neuronale Netze können daher als mehrere neuronale Feedforward-Netze betrachtet werden und Informationen von einem zum anderen Netz weitergeben werden.<ref>Towards Data Science: [https://towardsdatascience.com/learn-how-recurrent-neural-networks-work-84e975feaaf7 How Recurrent Neural Networks work]</ref>

Rekurrente künstliche neuronale Netze sind schwierig durch Methoden des [[Maschinelles Lernen|maschinellen Lernens]] zu trainieren.<ref>{{Internetquelle |url=http://snn.elis.ugent.be/rcbook |titel=Reservoir Computing |hrsg=Reservoir Lab Ghent |datum=2008-05-30 |offline=1 |archiv-url=https://web.archive.org/web/20100405215648/http://snn.elis.ugent.be/rcbook |archiv-datum=2010-04-05 |abruf=2010-04-02}}</ref> Ein populärer Ansatz ist es daher, nicht das Netz, sondern das Auslesen des Netzes zu trainieren. Das rekurrente neuronale Netz wird im Rahmen von [[Reservoir Computing]] als sogenanntes Reservoir betrachtet.
Im Falle von LSTMs werden die Netze durch [[Backpropagation-Through-Time]] (siehe [[Backpropagation]]) während des Trainingsvorgangs in ein Feedforward-Netz entsprechend der Sequenzlänge umgewandelt.<ref>{{Internetquelle |autor=Chris Nicholson, Adam Gibson |url=http://deeplearning4j.org/lstm.html |titel=A Beginner's Guide to Recurrent Networks and LSTMs - Deeplearning4j: Open-source, distributed deep learning for the JVM |werk=deeplearning4j.org |offline=1 |archiv-url=https://web.archive.org/web/20160716162501/http://www.deeplearning4j.org/lstm.html |archiv-datum=2016-07-16 |abruf=2016-07-16}}</ref> Damit wird die Komplexität des Lernverhaltens ähnlich dem der herkömmlichen Feedforward-Netze.

Ausgangspunkt für die Backpropagation-Through-Time ist, dass die totale Verlustfunktion der Zeitreihe, welche aus <math>T</math> Zeitschritten besteht, wie folgt dargestellt werden kann:
:<math>L=\sum_{t=1}^T l(y_t,o_t(\theta))</math>,
wobei <math>l</math> eine Funktion ist, welche die Ausgabe (Output) des Netzwerkens <math>o_t</math> (zum Zeitpunkt <math>t</math>) mit dem Ziel <math>y_t</math> vergleicht und wobei <math>\theta</math> der [[Zeitinvarianz|zeitinvariante]] Parametervektor des rekurrenten neuronalen Netzes ist.
Backpropagation-Through-Time erlaubt durch Anwenden der [[Kettenregel]] die Berechnung der (komponentenweisen) [[Totale Ableitung|totalen Ableitung]] <math>\frac{d L}{d \theta_i}</math>. Da der Output <math>o_t(h_{t-1}(\theta))</math> selbst von Werten <math>h_{t-1}</math> des vorherigen Zeitschrittes <math>t-1</math> abhängt und diese von <math>\theta</math>, müssen diese vorherigen Zeitschritte in die Ableitung mit einbezogen werden.

Probleme beim Training von rekurrenten neuronalen Netzen können aufgrund von verschwindenden oder explodierenden Gradienten auftreten. Um diese Probleme zu umgehen, kann [[Teacher-Forcing]] angewendet werden, wobei man jedoch den [[Bias-Exposure tradeoff]] eingeht.<ref>Quantifying Exposure Bias for Open-ended Language Generation https://arxiv.org/abs/1905.10617</ref>

== Aktivierungsfunktion ==
Die am häufigsten verwendeten [[Aktivierungsfunktion]]en für rekurrente neuronale Netze sind:<ref name=":0">Stanford University: [https://stanford.edu/~shervine/teaching/cs-230/cheatsheet-recurrent-neural-networks Recurrent Neural Networks cheatsheet]</ref><ref>Nico Frisch, Wenhao Peng, Tim Vieth, Mattes Westdörp, Universität zu Köln: [https://www.mi.uni-koeln.de/wp-znikolic/wp-content/uploads/2021/02/20210108_Neuronale_Netze.pdf Deep Feedforward Netze und Rekurrente Neuronale Netze]</ref>
* [[Sigmoidfunktion]]: <math>g(z) = \frac{1}{1 + e^{-z}}</math>
* [[Tangens hyperbolicus und Kotangens hyperbolicus|Tangens hyperbolicus]]: <math>g(z) = \frac{\mathrm{e}^z - \mathrm{e}^{-z}}{\mathrm{e}^z + \mathrm{e}^{-z}}</math>
* [[Rectifier (neuronale Netzwerke)|Rectifier]]: <math>g(z) = \max(0, z)</math>

== Verlustfunktion ==
Um ein rekurrentes neuronales Netz zu trainieren, braucht man eine Möglichkeit, die Fehler zu messen, die es macht. Dafür kann man eine sogenannte Verlustfunktion definieren. Ziel ist es, die Parameter zu finden, die die Verlustfunktion für die Trainingsdaten minimieren.

Eine übliche Verlustfunktion ist die [[Kreuzentropie]]. Ist <math>n</math> die Anzahl der Trainingsbeispiele, dann ist die Verlustfunktion in Bezug auf die Vorhersagen <math>o_n</math> und die wahren Labels <math>y_n</math> gegeben durch<ref>Denny’s Blog: [https://dennybritz.com/posts/wildml/recurrent-neural-networks-tutorial-part-2/ Recurrent Neural Networks Tutorial]</ref>
:<math>L(y, o) = -\frac{1}{n}\sum_{i=1}^{n}y_i\log(o_i)</math>

== Zielfunktionen ==
Mit einem geeigneten <math>P_\theta</math> fährt man fort, den Fehler aus den Zeitschritt zu minimieren und die Anpassung aus dem Aktualisierungsschritt zu maximieren. Dadurch wird jede Beobachtung des Ergebnisses <math>y(t)</math> zweimal verwendet. Der Wert des verborgenen Zustands vor einer Aktualisierung wir mit <math>z(t-)</math> bezeichnet und danach mit <math>z(t)</math>. Die Verlustfunktion für den Prognoseschritt ist die negative logarithmische Wahrscheinlichkeit der Daten:
:<math>L_{pred}(y_i, \theta) = -\sum_{i=1}^{N}\sum_{t=t_{0,i}}^{T_i}\log(p_\theta(y|z(t-))</math>
Dabei ist <math>z(t-)</math> der endgültige Wert des verborgenen Zustands vor dem Aktualisierungsschritt. Die zusätzliche Verlustfunktion, um sicherzustellen, dass nach dem Aktualisierungsschritt die durch den neuen Wert des verborgenen Zustands implizierte Ergebnisverteilung nahe beim beobachteten Datenpunkt <math>y(t)</math> liegt, ist
:<math>L_{jump}(y_i, \theta) = -\sum_{i=1}^{N}\sum_{t=t_{0,i}}^{T_i} m_i \log(p_\theta(y|z(t))</math>
Dabei ist <math>m_i</math> eine binäre Maske, die nützlich ist, wenn ein Aktualisierungsschritt erforderlich ist, z. B. aufgrund von Änderungen in <math>z(t)</math>, <math>y(t)</math> jedoch entweder nicht gemessen wird oder aus anderen Gründen fehlt. Wenn der Beobachtungsprozess mit Fehlern gemessen wird, können wir dies durch die Verwendung einer [[Kullback-Leibler-Divergenz]] als Verlustfunktion beschreiben:
:<math>L_{jump}(y_i, \theta) = -\sum_{i=1}^{N} KL(p_\theta(y|z(t)||p_{obs}(y,\sigma^2)))</math>
Dabei ist <math>p_{obs}(y,\sigma^2)</math> die angenommene Verteilung der Antwort <math>y(t)</math> bei gegebener Beobachtung <math>y</math> und der Annahme eines mittleren Messfehlers von Null mit [[Varianz]] <math>\sigma^2</math>.<ref>Oisin Fitzgerald, Oscar Perez-Concha, Blanca Gallego-Luxan, Alejandro Metke-Jimenez, Lachlan Rudd, Louisa Jorm: [https://arxiv.org/pdf/2304.07025 Continuous time recurrent neural networks: overview and application to forecasting blood glucose in the intensive care unit]</ref>

== GloVe Modell ==
Das GloVe Modell ist eine Worteinbettungstechnik, die eine Co-Occurence-Matrix <math>X</math> verwendet, wobei jedes <math>X_{i,j}</math> die Anzahl der Male bezeichnet, in denen ein Ziel <math>i</math> mit einem Kontext <math>j</math> aufgetreten ist. Die Kostenfunktion <math>J</math> für dieses Modell lautet
:<math>J(\theta) = \frac{1}{2} \sum_{i,j=1}^{|V|}f(X_{i,j})(\theta_i^Te_j+b_i+b_j'-\log(X_{i,j}))^2</math>
wobei <math>f</math> eine Gewichtungsfunktion ist, sodass <math>f(X_{i,j}) = 0</math> für alle <math>X_{i,j} = 0</math> ist.<ref name=":0" />

== Literatur ==

* Rajesh Arumugam u. a.: ''Hands-On Natural Language Processing with Python. A practical guide to applying deep learning architectures to your NLP applications.'' Packt, O. O. 2018, ISBN 978-1-78913-949-5.

* Andreas Zell: ''Simulation neuronaler Netze.'' R. Oldenbourg Verlag, München 1997, ISBN 3-486-24350-0.

== Weblinks ==
* {{Literatur
|Autor=Jeffrey L. Elman
|Titel=Finding Structure in Time
|Sammelwerk=Cognitive Science
|Auflage=
|Ort=
|Datum=1990-03
|ISBN=
|Seiten=
|DOI=10.1207/s15516709cog1402_1}}
* {{Literatur
|Autor=Michael I. Jordan
|Titel=Chapter 25 - Serial Order: A Parallel Distributed Processing Approach
|Sammelwerk=Advances in Psychology
|Band=121
|Auflage=
|Ort=
|Datum=
|ISBN=
|Seiten=471-495
|DOI=10.1016/S0166-4115(97)80111-2}}

== Einzelnachweise ==
<references>
<ref name="kruse-online">
{{Internetquelle
|autor=Rudolf Kruse et al.
|url=https://www.computational-intelligence.eu/?page_id=174
|titel=Neuronale Netze {{!}} Computational Intelligence
|werk=Computational Intelligence: Eine methodische Einführung in Künstliche Neuronale Netze, Evolutionäre Algorithmen, Fuzzy-Systeme und Bayes-Netze. Zweite Auflage
|hrsg=Springer-Vieweg, Wiesbaden 2015
|sprache=de
|abruf=2017-04-05}}
</ref>
<ref name="kruse-print">
{{Literatur
|Autor=[[Rudolf Kruse]] et al.
|Titel=Computational Intelligence: Eine methodische Einführung in Künstliche Neuronale Netze, Evolutionäre Algorithmen, Fuzzy-Systeme und Bayes-Netze
|Auflage=Zweite Auflage
|Verlag=Springer-Vieweg
|Ort=Wiesbaden
|Datum=2015
|ISBN=978-3-658-10903-5
|Seiten=515}}
</ref>
</references>

{{Normdaten|TYP=s|GND=4379549-3}}

[[Kategorie:Neuroinformatik]]
[[Kategorie:Künstliche Neuronale Netze]]
[[Kategorie:Computational Neuroscience]]

Rekurrentes neuronales Netz - Versionsgeschichte

imported>Rosa Olmos: /* Pseudocode */ def -> function