A recurrent neural network (RNN) reads a sequence one step at a time and carries a single running summary — its hidden state — from each step to the next. That hidden state is the network's whole memory of everything it has read so far.

Where you meet it

• A deep-learning or NLP course, in the stretch just before transformers — RNNs are how neural sequence models worked first.
• Anything with an order to it: text, speech, sensor streams, prices over time, a melody.
• Framework code you'll copy: nn.RNN in PyTorch, SimpleRNN in Keras.
• Exam questions like "what is backpropagation through time?" or "why do RNNs forget?"

What it does

An RNN turns a variable-length sequence into an output by walking through it step by step. At each step it mixes the new input with what it already remembers, then updates that memory. The hidden state is the only bridge between past and future — everything the network knows about earlier steps has to fit inside that one fixed-size vector.

The hidden state is a fixed-size summary the network rewrites at every step — the past survives only as long as it keeps being copied forward.

How it works

At each step t the RNN builds a new hidden state from the previous one and the current input:

hₜ = tanh(Wₕ · hₜ₋₁ + Wₓ · xₜ)

In plain words: take last step's memory hₜ₋₁, scale it by the recurrent weight Wₕ, add the new input xₜ scaled by Wₓ, and squash the total with tanh into the range −1 to 1. Two things make it recurrent: the same weights are reused at every step — so one small cell handles a sequence of any length — and the new hₜ feeds straight back in as the memory for step t+1.

Unroll a few steps and you can see why the memory is fragile — watch how the first input keeps getting multiplied by Wₕ:

h₁ = tanh(Wₕ·h₀ + Wₓ·x₁)   # h₀ enters, scaled by Wₕ
h₂ = tanh(Wₕ·h₁ + Wₓ·x₂)   # h₀'s trace is now ≈ Wₕ² of its start
h₃ = tanh(Wₕ·h₂ + Wₓ·x₃)   # ≈ Wₕ³ … one factor of Wₕ per step

So an early input's influence scales roughly like Wₕᵏ after k steps. If Wₕ is a little under 1, that shrinks toward zero and old inputs fade; a little over 1 and it blows up. The very same repeated factor makes the training gradients vanish or explode when they flow back through the unrolled chain — running backprop over that chain is backpropagation through time.

Watch out

Memory that must be copied forward at every step is memory that slowly leaks away — exactly the problem the LSTM was built to fix.

Go deeper

• Stanford CS230 — Recurrent Neural Networks cheatsheet
• Deep Learning (Goodfellow, Bengio, Courville) — Ch. 10, Sequence Modeling: Recurrent and Recursive Nets
• Pascanu, Mikolov & Bengio (2013) — On the difficulty of training Recurrent Neural Networks

Ein rekurrentes neuronales Netz (RNN) liest eine Sequenz Schritt für Schritt und trägt eine einzige laufende Zusammenfassung — seinen Hidden State — von jedem Schritt zum nächsten. Dieser Hidden State ist das gesamte Gedächtnis des Netzes für alles bisher Gelesene.

Wo es vorkommt

• In einer Deep-Learning- oder NLP-Vorlesung, kurz vor den Transformern — so funktionierten neuronale Sequenzmodelle zuerst.
• Überall, wo Reihenfolge zählt: Text, Sprache, Sensordaten, Kurse über die Zeit, eine Melodie.
• Framework-Code zum Kopieren: nn.RNN in PyTorch, SimpleRNN in Keras.
• Prüfungsfragen wie „Was ist Backpropagation durch die Zeit?" oder „Warum vergessen RNNs?"

Was es tut

Ein RNN verwandelt eine Sequenz variabler Länge in eine Ausgabe, indem es sie Schritt für Schritt durchläuft. In jedem Schritt mischt es die neue Eingabe mit dem, was es schon erinnert, und aktualisiert dieses Gedächtnis. Der Hidden State ist die einzige Brücke zwischen Vergangenheit und Zukunft — alles, was das Netz über frühere Schritte weiß, muss in diesen einen Vektor fester Größe passen.

Der Hidden State ist eine Zusammenfassung fester Größe, die das Netz bei jedem Schritt überschreibt — die Vergangenheit überlebt nur so lange, wie sie weiterkopiert wird.

Wie es funktioniert

In jedem Schritt t baut das RNN einen neuen Hidden State aus dem vorherigen und der aktuellen Eingabe:

hₜ = tanh(Wₕ · hₜ₋₁ + Wₓ · xₜ)

In Worten: Nimm das Gedächtnis des letzten Schritts hₜ₋₁, skaliere es mit dem rekurrenten Gewicht Wₕ, addiere die neue Eingabe xₜ skaliert mit Wₓ, und quetsche die Summe mit tanh in den Bereich −1 bis 1. Zwei Dinge machen es rekurrent: Die gleichen Gewichte werden in jedem Schritt wiederverwendet — so bewältigt eine kleine Zelle eine Sequenz beliebiger Länge — und das neue hₜ fließt direkt als Gedächtnis für Schritt t+1 zurück.

Rollt man ein paar Schritte aus, sieht man, warum das Gedächtnis fragil ist — verfolge, wie die erste Eingabe immer wieder mit Wₕ multipliziert wird:

h₁ = tanh(Wₕ·h₀ + Wₓ·x₁)   # h₀ tritt ein, skaliert mit Wₕ
h₂ = tanh(Wₕ·h₁ + Wₓ·x₂)   # Spur von h₀ jetzt ≈ Wₕ² des Starts
h₃ = tanh(Wₕ·h₂ + Wₓ·x₃)   # ≈ Wₕ³ … ein Faktor Wₕ pro Schritt

Der Einfluss einer frühen Eingabe skaliert also nach k Schritten grob wie Wₕᵏ. Ist Wₕ etwas kleiner als 1, schrumpft das gegen null und alte Eingaben verblassen; etwas größer als 1, und es explodiert. Genau derselbe wiederholte Faktor lässt die Trainingsgradienten verschwinden oder explodieren, wenn sie durch die ausgerollte Kette zurückfließen — Backprop über diese Kette heißt Backpropagation durch die Zeit.

Worauf achten

Gedächtnis, das bei jedem Schritt weiterkopiert werden muss, ist Gedächtnis, das langsam versickert — genau das Problem, für das das LSTM gebaut wurde.

Mehr dazu

• Stanford CS230 — Recurrent Neural Networks cheatsheet
• Deep Learning (Goodfellow, Bengio, Courville) — Kap. 10, Sequence Modeling: Recurrent and Recursive Nets
• Pascanu, Mikolov & Bengio (2013) — On the difficulty of training Recurrent Neural Networks