Der vollständige Leitfaden zu Rekurrenten Neuronalen Netzen: Von der Sequenzmodellierung bis zur LSTM-Praxis — die Kern-Engine der Zeitreihen-KI beherrschen

I. Die Macht der Sequenz: Warum die Welt RNNs braucht

In der Geschichte des Deep Learning gibt es eine grundlegende Herausforderung: Wie bringt man einem neuronalen Netz bei, „Reihenfolge" zu verstehen? Herkömmliche vollvernetzte Netze und Convolutional Neural Networks verarbeiten Eingaben fester Größe — ein Bild, einen Satz von Merkmalen. Doch die reale Welt ist voller Sequenzdaten: Sprache ist eine Sequenz von Wörtern, Audio eine Sequenz von Schallwellen, Aktienkurse eine Sequenz über die Zeit, Videos eine Sequenz von Frames.

1990 schlug Jeffrey Elman das Simple Recurrent Network (SRN)^[1] vor und führte ein scheinbar einfaches, aber zutiefst bedeutsames Design ein: die Rückführung des Hidden State des vorherigen Zeitschritts in den aktuellen Zeitschritt. Diese „Schleife" gab dem Netzwerk ein Gedächtnis — es sah nicht mehr nur die aktuelle Eingabe, sondern konnte sich auch an früher Gesehenes „erinnern".

Die Kernformel des RNN ist elegant und prägnant:

h_t = tanh(W_hh · h_{t-1} + W_xh · x_t + b_h)
y_t = W_hy · h_t + b_y

Dabei gilt:
  h_t = Hidden State (Gedächtnis) zum Zeitschritt t
  x_t = Eingabe zum Zeitschritt t
  y_t = Ausgabe zum Zeitschritt t
  W_hh, W_xh, W_hy = Gewichtsmatrizen (über alle Zeitschritte geteilt)

Dieses Design der Gewichtsteilung ist ein großer Vorteil von RNNs: Unabhängig von der Sequenzlänge bleibt die Anzahl der Modellparameter konstant. Ein trainiertes RNN kann sowohl einen Satz mit 10 Wörtern als auch einen Artikel mit 1000 Wörtern verarbeiten.

II. Vanishing Gradient: Die fatale Schwäche des RNN

Theoretisch kann ein RNN Abhängigkeiten über beliebig weite Distanzen erfassen. In der Praxis offenbarte die Forschung von Bengio et al. aus dem Jahr 1994^[3] jedoch eine ernüchternde Realität: Das Vanishing-Gradient-Problem macht es einem Standard-RNN nahezu unmöglich, langfristige Abhängigkeiten über mehr als 10–20 Schritte hinweg zu erlernen.

Die Ursache liegt im mathematischen Wesen der Backpropagation Through Time (BPTT)^[12]. In einem zeitlich entfalteten RNN muss der Gradient über mehrere Zeitschritte hinweg multipliziert werden:

∂L/∂h_0 = ∂L/∂h_T · ∂h_T/∂h_{T-1} · ... · ∂h_1/∂h_0

Jeder Term ∂h_t/∂h_{t-1} beinhaltet wiederholte Multiplikation mit W_hh:
- Falls der größte Eigenwert von W_hh < 1 → Gradient schrumpft exponentiell (Vanishing)
- Falls der größte Eigenwert von W_hh > 1 → Gradient wächst exponentiell (Exploding)

Anschaulich erklärt: Wenn Sie ein Standard-RNN bitten, sich an „das erste Wort" zu erinnern, um das 100. Wort vorherzusagen, muss der Gradient 99 Zeitschritte durchlaufen. Bei jedem Schritt wird er mit einem Wert kleiner als 1 multipliziert — nach 99 Multiplikationen ist der Gradient praktisch null und das Netzwerk kann diese langfristige Abhängigkeit schlicht „nicht erlernen".

III. LSTM: Die Revolution der Gate-gesteuerten Speicher

1997 schlugen Sepp Hochreiter und Jürgen Schmidhuber das Long Short-Term Memory (LSTM)-Netzwerk^[2] vor, das mit einem ausgeklügelten Gate-Mechanismus das Vanishing-Gradient-Problem grundlegend löste. Die Kerninnovation von LSTM ist die Einführung einer „Gedächtnis-Schnellstraße" (Cell State), die es Informationen ermöglicht, ohne Verlust über mehrere Zeitschritte hinweg zu fließen.

Eine LSTM-Zelle umfasst drei Gates und einen Speicherkanal:

Warum kann LSTM das Vanishing-Gradient-Problem lösen? Der Schlüssel liegt in der Aktualisierungsformel des Cell State: C_t = f_t ⊙ C_{t-1} + i_t ⊙ C̃_t. Dies ist eine additive Struktur und keine multiplikative — der Gradient kann direkt entlang des Cell State fließen, ohne fortlaufend multipliziert zu werden. Wenn das Forget Gate nahe 1 liegt, wird der Gradient nahezu verlustfrei in die weit zurückliegende Vergangenheit übertragen.

IV. GRU: Ein schlankeres Gate-Design

2014 schlugen Cho et al. die Gated Recurrent Unit (GRU)^[4] vor, die als vereinfachte Version des LSTM betrachtet werden kann. GRU vereint Forget Gate und Input Gate zu einem einzigen Update Gate und verzichtet auf einen separaten Cell State, wodurch die Parameteranzahl um etwa 25 % reduziert wird.

# GRU-Kernformeln
z_t = σ(W_z · [h_{t-1}, x_t])     # Update Gate: Wie viel alte Erinnerung behalten
r_t = σ(W_r · [h_{t-1}, x_t])     # Reset Gate: Wie viel alte Erinnerung vergessen
h̃_t = tanh(W · [r_t ⊙ h_{t-1}, x_t])  # Kandidaten-Hidden-State
h_t = (1 - z_t) ⊙ h_{t-1} + z_t ⊙ h̃_t  # Hidden State aktualisieren

Die empirische Studie von Chung et al.^[16] zeigt, dass GRU und LSTM bei den meisten Sequenzaufgaben vergleichbare Ergebnisse liefern. Der Vorteil von GRU liegt in der schnelleren Trainingszeit und dem geringeren Speicherverbrauch, was sie besonders für ressourcenbeschränkte Szenarien geeignet macht.

V. Fortgeschrittene RNN-Architekturen: Bidirektional, Gestapelt, Seq2Seq

5.1 Bidirektionales RNN (Bidirectional RNN)

Das von Schuster und Paliwal^[5] vorgestellte bidirektionale RNN nutzt gleichzeitig Hidden States aus zwei Richtungen: vorwärts (von der Vergangenheit zur Gegenwart) und rückwärts (von der Zukunft zur Gegenwart). Die endgültige Hidden-Repräsentation ist die Konkatenation beider Richtungen, sodass das Modell gleichzeitig den vollständigen Kontext nutzen kann. Bei Aufgaben wie Named Entity Recognition und Part-of-Speech-Tagging war das bidirektionale LSTM lange Zeit die Standardkonfiguration.

5.2 Tiefe / Gestapelte RNNs

Graves et al.^[8] zeigten, dass das Stapeln mehrerer RNN-Schichten (wobei die Ausgabe jeder Schicht als Eingabe der nächsten dient) abstraktere Sequenzrepräsentationen erlernen kann. In Kombination mit Dropout^[14]-Regularisierung erzielten tiefe LSTMs bahnbrechende Ergebnisse in der Spracherkennung.

5.3 Seq2Seq und Attention-Mechanismus

2014 schlugen Sutskever et al.^[6] die Sequence-to-Sequence-Architektur (Seq2Seq) vor: Ein LSTM-Encoder komprimiert die Eingabesequenz in einen Vektor fester Dimension, und ein LSTM-Decoder generiert aus diesem Vektor die Ausgabesequenz. Diese Architektur erzielte beeindruckende Erfolge in der maschinellen Übersetzung.

Allerdings stellt die Komprimierung der gesamten Eingabesequenz in einen einzelnen Vektor fester Länge einen Informationsengpass dar. 2015 führten Bahdanau et al.^[7] den Attention-Mechanismus ein, der es dem Decoder ermöglicht, bei der Generierung jedes Wortes auf alle Hidden States des Encoders „zurückzublicken" und sich dynamisch auf die relevantesten Teile der Eingabe zu fokussieren. Der Attention-Mechanismus verbesserte nicht nur die Übersetzungsqualität erheblich, sondern ebnete auch den Weg für den späteren Transformer^[11].

VI. Das Anwendungsspektrum von RNNs

VII. Hands-on Lab 1: LSTM-Textgenerierung im Shakespeare-Stil (Google Colab)

In diesem Praxisprojekt trainieren wir ein zeichenbasiertes LSTM-Modell zur Generierung von Text im Shakespeare-Stil^[10]. Das Modell erlernt die statistischen Muster zwischen Zeichen und generiert dann Zeichen für Zeichen völlig neuen Text.

# ============================================================
# Hands-on Lab 1: LSTM Zeichenbasierte Textgenerierung
# Umgebung: Google Colab (kostenlose GPU)
# Geschätzte Laufzeit: ca. 8 Minuten
# ============================================================

import torch
import torch.nn as nn
import numpy as np

# ------ 1. Daten vorbereiten: Shakespeare-Text herunterladen ------
import urllib.request
url = "https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt"
urllib.request.urlretrieve(url, "shakespeare.txt")

with open("shakespeare.txt", "r") as f:
    text = f.read()

print(f"Textlänge: {len(text):,} Zeichen")
print(f"Erste 200 Zeichen:\n{text[:200]}")

# Zeichen ↔ Index-Zuordnung erstellen
chars = sorted(set(text))
vocab_size = len(chars)
char_to_idx = {c: i for i, c in enumerate(chars)}
idx_to_char = {i: c for i, c in enumerate(chars)}
print(f"Vokabular: {vocab_size} verschiedene Zeichen")

# Text kodieren
data = np.array([char_to_idx[c] for c in text])

# ------ 2. Trainingsdatensatz erstellen ------
seq_length = 100
batch_size = 64

def get_batch(data, seq_length, batch_size):
    """Zufällig einen Batch von Sequenzen sampeln"""
    max_start = len(data) - seq_length - 1
    starts = np.random.randint(0, max_start, size=batch_size)
    x = np.array([data[s:s+seq_length] for s in starts])
    y = np.array([data[s+1:s+seq_length+1] for s in starts])
    return torch.tensor(x, dtype=torch.long), torch.tensor(y, dtype=torch.long)

# ------ 3. LSTM-Modell definieren ------
class CharLSTM(nn.Module):
    def __init__(self, vocab_size, embed_dim=128, hidden_dim=256, num_layers=2, dropout=0.3):
        super().__init__()
        self.hidden_dim = hidden_dim
        self.num_layers = num_layers
        self.embed = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers,
                           batch_first=True, dropout=dropout)
        self.fc = nn.Linear(hidden_dim, vocab_size)

    def forward(self, x, hidden=None):
        emb = self.embed(x)                    # (batch, seq, embed)
        out, hidden = self.lstm(emb, hidden)    # (batch, seq, hidden)
        logits = self.fc(out)                   # (batch, seq, vocab)
        return logits, hidden

    def init_hidden(self, batch_size, device):
        h = torch.zeros(self.num_layers, batch_size, self.hidden_dim, device=device)
        c = torch.zeros(self.num_layers, batch_size, self.hidden_dim, device=device)
        return (h, c)

# ------ 4. Training ------
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Verwendetes Gerät: {device}")

model = CharLSTM(vocab_size).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.002)
criterion = nn.CrossEntropyLoss()

print(f"Modellparameter: {sum(p.numel() for p in model.parameters()):,}")

num_steps = 3000
for step in range(1, num_steps + 1):
    model.train()
    x, y = get_batch(data, seq_length, batch_size)
    x, y = x.to(device), y.to(device)

    logits, _ = model(x)
    loss = criterion(logits.view(-1, vocab_size), y.view(-1))

    optimizer.zero_grad()
    loss.backward()
    nn.utils.clip_grad_norm_(model.parameters(), 5.0)  # Gradient Exploding verhindern
    optimizer.step()

    if step % 500 == 0:
        print(f"Step {step}/{num_steps}, Loss: {loss.item():.4f}")

# ------ 5. Textgenerierung ------
def generate(model, start_text="ROMEO:\n", length=500, temperature=0.8):
    """Mit dem trainierten Modell Text generieren"""
    model.eval()
    chars_idx = [char_to_idx[c] for c in start_text]
    hidden = model.init_hidden(1, device)

    # Zuerst den Kontext mit start_text aufbauen
    for ch_idx in chars_idx[:-1]:
        inp = torch.tensor([[ch_idx]], device=device)
        _, hidden = model(inp, hidden)

    generated = list(start_text)
    inp = torch.tensor([[chars_idx[-1]]], device=device)

    with torch.no_grad():
        for _ in range(length):
            logits, hidden = model(inp, hidden)
            logits = logits[0, -1] / temperature
            probs = torch.softmax(logits, dim=0)
            next_idx = torch.multinomial(probs, 1).item()
            generated.append(idx_to_char[next_idx])
            inp = torch.tensor([[next_idx]], device=device)

    return "".join(generated)

# Wirkung verschiedener Temperature-Werte
for temp in [0.5, 0.8, 1.2]:
    print(f"\n{'='*60}")
    print(f"Temperature = {temp}")
    print(f"{'='*60}")
    print(generate(model, temperature=temp))

Die Bedeutung des Temperature-Parameters: temperature < 1 macht die Ausgabe konservativer und „korrekter", aber weniger abwechslungsreich; temperature > 1 erhöht die Zufälligkeit und Kreativität, kann aber inkohärenten Text erzeugen. temperature = 0,8 ist in der Regel der optimale Kompromiss zwischen Qualität und Vielfalt.

VIII. Hands-on Lab 2: LSTM-Bildsequenzklassifikation — MNIST als Zeitreihe (Google Colab)

RNNs können nicht nur Text verarbeiten — alle Daten, die sich als Sequenz darstellen lassen, sind ein Spielfeld für RNNs. In diesem Praxisprojekt behandeln wir MNIST-Bilder mit 28×28 Pixeln als 28 Zeitschritte mit jeweils 28 Pixelwerten als Eingabe. Das LSTM „scannt" das Bild zeilenweise und klassifiziert es schließlich anhand des akkumulierten Hidden State^[13].

# ============================================================
# Hands-on Lab 2: LSTM Bildsequenzklassifikation (MNIST as Sequence)
# Umgebung: Google Colab (kostenlose GPU)
# Geschätzte Laufzeit: ca. 5 Minuten
# ============================================================

import torch
import torch.nn as nn
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np

# ------ 1. MNIST-Datensatz laden ------
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
train_data = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_data = datasets.MNIST('./data', train=False, transform=transform)
train_loader = DataLoader(train_data, batch_size=128, shuffle=True)
test_loader = DataLoader(test_data, batch_size=256, shuffle=False)
print(f"Trainingsdatensatz: {len(train_data)} Bilder, Testdatensatz: {len(test_data)} Bilder")

# ------ 2. Visualisierung: MNIST als Sequenz ------
fig, axes = plt.subplots(1, 3, figsize=(14, 4))
sample_img = train_data[0][0].squeeze().numpy()

# Originalbild
axes[0].imshow(sample_img, cmap='gray')
axes[0].set_title("Originalbild 28×28", fontsize=12)

# Zeilenweise als Sequenz entfaltet
seq_view = sample_img.copy()
for i in range(0, 28, 4):
    axes[1].axhline(y=i, color='cyan', alpha=0.3, linewidth=0.5)
axes[1].imshow(seq_view, cmap='gray')
axes[1].set_title("LSTM scannt zeilenweise (28 steps × 28 features)", fontsize=12)
for i, arrow_y in enumerate(range(2, 26, 3)):
    axes[1].annotate('→', xy=(26, arrow_y), fontsize=8, color='cyan', alpha=0.6)

# Pixelwerte der ersten Zeilen
axes[2].plot(sample_img[:8].T, alpha=0.7)
axes[2].set_xlabel("Pixelposition (0-27)")
axes[2].set_ylabel("Pixelwert")
axes[2].set_title("Pixelwertsequenzen der ersten 8 Zeilen", fontsize=12)
axes[2].legend([f"row {i}" for i in range(8)], fontsize=7, ncol=2)
plt.tight_layout()
plt.savefig("mnist_as_sequence.png", dpi=150, bbox_inches='tight')
plt.show()

# ------ 3. LSTM-Klassifikationsmodell definieren ------
class ImageLSTM(nn.Module):
    """
    Behandelt ein 28×28-Bild als 28-Schritt-Sequenz mit jeweils 28-dimensionalen Merkmalen.
    LSTM liest zeilenweise und klassifiziert anhand des Hidden State des letzten Schritts.
    """
    def __init__(self, input_size=28, hidden_size=128, num_layers=2,
                 num_classes=10, dropout=0.3, bidirectional=True):
        super().__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.bidirectional = bidirectional
        self.num_directions = 2 if bidirectional else 1

        self.lstm = nn.LSTM(input_size, hidden_size, num_layers,
                           batch_first=True, dropout=dropout,
                           bidirectional=bidirectional)
        self.dropout = nn.Dropout(dropout)
        self.fc = nn.Linear(hidden_size * self.num_directions, num_classes)

    def forward(self, x):
        # x: (batch, 1, 28, 28) → (batch, 28, 28)
        x = x.squeeze(1)  # Channel-Dimension entfernen

        # LSTM verarbeitet Sequenz: 28 Schritte, jeweils 28 Dimensionen
        out, (h_n, c_n) = self.lstm(x)

        # Letzten Ausgabeschritt zur Klassifikation verwenden
        if self.bidirectional:
            # Vorwärts- und Rückwärts-Hidden-State des letzten Schritts konkatenieren
            last_hidden = torch.cat([h_n[-2], h_n[-1]], dim=1)
        else:
            last_hidden = h_n[-1]

        out = self.dropout(last_hidden)
        logits = self.fc(out)
        return logits

# ------ 4. Training ------
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ImageLSTM().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
print(f"Modellparameter: {sum(p.numel() for p in model.parameters()):,}")
print(f"Verwendetes Gerät: {device}")

num_epochs = 10
train_losses, test_accs = [], []

for epoch in range(1, num_epochs + 1):
    model.train()
    total_loss = 0
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)
        logits = model(images)
        loss = criterion(logits, labels)

        optimizer.zero_grad()
        loss.backward()
        nn.utils.clip_grad_norm_(model.parameters(), 5.0)
        optimizer.step()
        total_loss += loss.item()

    avg_loss = total_loss / len(train_loader)
    train_losses.append(avg_loss)

    # Test
    model.eval()
    correct, total = 0, 0
    with torch.no_grad():
        for images, labels in test_loader:
            images, labels = images.to(device), labels.to(device)
            preds = model(images).argmax(dim=1)
            correct += (preds == labels).sum().item()
            total += labels.size(0)
    acc = correct / total
    test_accs.append(acc)
    print(f"Epoch {epoch}/{num_epochs}, Loss: {avg_loss:.4f}, Test Acc: {acc:.4f}")

# ------ 5. Trainingsverlauf visualisieren ------
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
ax1.plot(train_losses, 'b-', linewidth=2)
ax1.set_xlabel("Epoch"); ax1.set_ylabel("Loss"); ax1.set_title("Training Loss")
ax1.grid(True, alpha=0.3)

ax2.plot([a*100 for a in test_accs], 'r-', linewidth=2)
ax2.set_xlabel("Epoch"); ax2.set_ylabel("Accuracy (%)"); ax2.set_title("Test Accuracy")
ax2.grid(True, alpha=0.3)
ax2.set_ylim([90, 100])
plt.tight_layout()
plt.savefig("lstm_mnist_training.png", dpi=150, bbox_inches='tight')
plt.show()

print(f"\nEndgültige Testgenauigkeit: {test_accs[-1]*100:.2f}%")
print("BiLSTM erreicht auch bei sequenzieller Bildverarbeitung ~98% Genauigkeit!")

# ------ 6. Hidden-State-Entwicklung visualisieren ------
model.eval()
sample = test_data[0][0].unsqueeze(0).to(device)

# Hidden State für jeden Zeitschritt extrahieren
with torch.no_grad():
    x = sample.squeeze(1)  # (1, 28, 28)
    h_states = []
    h = None
    for t in range(28):
        step_input = x[:, t:t+1, :]  # (1, 1, 28)
        out, h = model.lstm(step_input, h)
        h_states.append(h[0][-1].cpu().numpy())  # Letzten Layer-h nehmen

h_states = np.array(h_states).squeeze()  # (28, hidden_size)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
ax1.imshow(sample.cpu().squeeze(), cmap='gray')
ax1.set_title("Eingabebild", fontsize=12)

im = ax2.imshow(h_states.T[:32], aspect='auto', cmap='RdYlBu_r')
ax2.set_xlabel("Zeitschritt (Zeilenscanning)")
ax2.set_ylabel("Hidden Units (erste 32)")
ax2.set_title("Entwicklung des LSTM-Hidden-State über die Zeitschritte", fontsize=12)
plt.colorbar(im, ax=ax2)
plt.tight_layout()
plt.savefig("lstm_hidden_states.png", dpi=150, bbox_inches='tight')
plt.show()

Warum ist es sinnvoll, Bilder als Sequenzen zu betrachten? Der pädagogische Wert dieses Experiments liegt darin: (1) Es beweist, dass LSTM die räumliche Struktur aus einer rein sequenziellen Perspektive „verstehen" kann; (2) Das bidirektionale LSTM erreicht ca. 98 % Genauigkeit, was zeigt, dass zeilenweises Scannen tatsächlich ausreichend räumliche Information erfassen kann; (3) Die Hidden-State-Visualisierung offenbart die interne Dynamik des LSTM bei der Verarbeitung handgeschriebener Ziffern.

IX. Von RNN zu Transformer: Der Staffellauf der Geschichte

2017 veröffentlichten Vaswani et al. die bahnbrechende Arbeit „Attention Is All You Need"^[11] und stellten die vollständig auf dem Self-Attention-Mechanismus basierende Transformer-Architektur vor, die die rekurrente Struktur des RNN komplett hinter sich ließ. Die Vorteile des Transformers sind:

• Parallelisierung: Ein RNN muss jeden Zeitschritt sequenziell verarbeiten; ein Transformer kann die gesamte Sequenz gleichzeitig verarbeiten
• Langfristige Abhängigkeiten: Der Self-Attention-Mechanismus ermöglicht eine Distanz von O(1) zwischen beliebigen zwei Positionen, während es beim RNN O(n) ist
• Skalierbarkeit: Die Leistung des Transformers verbessert sich stetig mit wachsender Modellgröße und Datenmenge

Dennoch wurden RNNs nicht vollständig ersetzt. In folgenden Szenarien besitzen RNNs weiterhin Vorteile:

X. Fazit: Die Macht des Gedächtnisses

Von Elmans Simple Recurrent Network^[1] über Hochreiters und Schmidhubers LSTM^[2] bis hin zu Bahdanaus Attention-Mechanismus^[7] — die Entwicklungsgeschichte der RNNs ist eines der faszinierendsten Kapitel des Deep Learning. Jeder Durchbruch entsprang einem tieferen Verständnis der grundlegenden Frage des „Gedächtnisses":

• RNN beantwortete die Frage „Wie kann ein Netzwerk sich an die Vergangenheit erinnern?"
• LSTM beantwortete die Frage „Wie kann man selektiv erinnern und vergessen?"
• Attention-Mechanismus beantwortete die Frage „Wie kann man sich dynamisch auf relevante Informationen fokussieren?"
• Transformer beantwortete die Frage „Wie können alle Positionen gleichberechtigt kommunizieren?"

RNNs zu verstehen ist nicht nur eine historische Betrachtung — es ist das Fundament zum Verständnis des modernen Deep Learning. Viele Kernkonzepte des Transformers (Encoder-Decoder, Attention, Sequenzmodellierung) stammen aus der Forschungstradition der RNNs. Wer RNNs beherrscht, besitzt den Schlüssel zur Welt von GPT, BERT und LLMs^[13].