Deep Learning, das Wesentliche: Backpropagation, Batch-Normalisierung, ResNet, Faltung, LSTM, Aufmerksamkeit, VAE und GAN, hergeleitet und überprüft

Der Berechnungsgraph: Backpropagation durchläuft ihn rückwärts

Eine Formel lässt sich als Kette kleiner Operationen zeichnen; um alle Ableitungen auf einmal zu erhalten, geht man diese Kette vom Ende her ab, und jeder Kasten multipliziert mit seiner eigenen Steigung.

Alles, was eine Deep-Learning-Bibliothek beim Aufruf von loss.backward() tut, beruht auf einer einzigen Zerlegung; sie heißt Berechnungsgraph (computational graph). Der Vorwärtsdurchlauf zeichnet jede elementare Operation als Knoten eines gerichteten azyklischen Graphen auf und trägt ihren Wert ein. Der Rückwärtsdurchlauf beginnt beim Verlust, dessen Ableitung nach sich selbst 1 ist, und besucht die Knoten in umgekehrter Reihenfolge. Jeder Knoten braucht nur seine lokale Ableitung: Eine Summe reicht den ankommenden Gradienten unverändert an jeden Eingang weiter, ein Skalarprodukt multipliziert ihn mit dem anderen Faktor, ein Quadrat multipliziert ihn mit dem Doppelten seines Arguments. Erreicht eine Größe den Verlust über mehrere Wege, werden die Beiträge addiert; deshalb akkumulieren sich Gradienten in PyTorch und müssen vor jedem Schritt zurückgesetzt werden.

Das Neuron des Foliensatzes: $x = (1, 1)$, $w = (0.8, -1.4)$, $b = 0.6$, Zielwert $y = 1$

1. Vorwärtsdurchlauf. Das Skalarprodukt ergibt $u = 0.8 - 1.4 = -0.6$, der Bias bringt die Vorhersage auf $\hat y = 0$, und der quadratische Verlust beträgt $L = 1$.
2. Verlustknoten. Die Ableitung des Quadrats ist $-2(y - \hat y) = -2$. Das Vorzeichen besagt, dass eine höhere Vorhersage den Verlust senken würde: Wir liegen unter dem Zielwert.
3. Summenknoten. Er gibt $-2$ unverändert an den Bias und an $u$ weiter, der Gradient von $b$ ist also $-2$.
4. Skalarproduktknoten. Er multipliziert mit dem anderen Faktor, $x = (1, 1)$, der Gradient von $w$ ist also $(-2, -2)$.
5. Ein Schritt. Mit einer Lernrate von 0,1 wird $w$ zu $(1.0, -1.2)$ und $b$ zu 0,8, die Vorhersage steigt auf 0,6, und der Verlust fällt von 1 auf 0,16.

import torch
x = torch.tensor([1.0, 1.0])
w = torch.tensor([0.8, -1.4], requires_grad=True)
b = torch.tensor(0.6, requires_grad=True)
loss = (1.0 - (w @ x + b)) ** 2   # hier wird der Graph aufgezeichnet
loss.backward()                    # Rückwärtsdurchlauf über den Graphen
print(w.grad, b.grad)              # tensor([-2., -2.]) tensor(-2.)

Entscheidend ist der Aufwand. Die automatische Differentiation (automatic differentiation) im Rückwärtsmodus (Linnainmaa, 1970, für neuronale Netze bekannt gemacht durch Rumelhart, Hinton und Williams 1986) liefert den Gradienten nach allen Parametern ungefähr zum Preis eines einzigen Vorwärtsdurchlaufs, während finite Differenzen einen Durchlauf pro Parameter bräuchten. Erst das macht ein Modell mit einer Milliarde Gewichten trainierbar. Dieselbe Technik berechnet in Handelsräumen unter dem Namen adjungierte algorithmische Differentiation alle Sensitivitäten eines Portfolios in einem einzigen Rückwärtsdurchlauf. Ihre praktische Grenze ist der Speicher, nicht die Rechenleistung: Der Graph behält jede Zwischenaktivierung, und genau deshalb gibt es Gradient Checkpointing.

Zurück zum Inhalt.

Was der Verlust schätzt und wie schnell der Schritt dorthin führt

Ein Klassifikator, der mit quadratischem Fehler auf 0/1-Labels trainiert wird, sagt am Ende eine Wahrscheinlichkeit voraus, und der Gradientenabstieg kommt im Tempo der flachsten Richtung des Tals voran, während die steilste seinen Schritt begrenzt.

Der quadratische Fehler auf 0/1-Zielwerten lernt die A-posteriori-Wahrscheinlichkeit

Man hält eine Eingabe $x$ fest und nimmt an, dass ein Anteil $p$ der Kunden mit genau diesem Profil ausfällt. Der mittlere quadratische Fehler einer Vorhersage $F$ bei diesen Kunden ist eine Parabel in $F$ mit dem Minimum bei $p$. Bei $p = 0.7$ beträgt das Risiko 0,250 für $F = 0.5$, 0,210 für $F = 0.7$ und wieder 0,250 für $F = 0.9$. Ein Modell, das flexibel genug ist, um seinen Wert an jedem $x$ frei zu wählen, konvergiert daher gegen $P(y = 1 \mid x)$. Nichts daran ist spezifisch für neuronale Netze, und ein eingeschränktes Modell erreicht nur den besten Kompromiss innerhalb seiner Familie.

Die Kreuzentropie hat denselben Minimierer. Anders ist der Gradient nach dem Logit: Beim quadratischen Fehler enthält er den Faktor $\sigma(1 - \sigma)$, der das Lernen erstickt, wenn ein Neuron selbstsicher danebenliegt; bei der Kreuzentropie ist er schlicht $\sigma - y$. Daraus folgen zwei praktische Warnungen. Ein Score ist nur dann eine Wahrscheinlichkeit, wenn das Modell kalibriert ist, was man an einer Zuverlässigkeitskurve prüft, wie in der Sitzung zu Entscheidungsschwellen. Und wer die Ausfälle per Oversampling vervielfacht, verändert das $p$, das das Modell lernt; seine Ausgabe muss dann korrigiert werden, bevor man sie als Wahrscheinlichkeit liest.

Die Hesse-Matrix und die Konditionszahl

In der Nähe eines Minimums verhält sich der Verlust wie eine quadratische Mulde, die durch ihre Hesse-Matrix $H$ beschrieben wird. In der Basis ihrer Eigenvektoren geschrieben, multipliziert ein Gradientenschritt den Abstand zum Minimum entlang der Achse $i$ mit $1 - \varepsilon\lambda_i$, jede Achse folgt also ihrer eigenen geometrischen Folge. Die steilste Achse legt den größten Schritt fest, der nicht divergiert, die flachste bestimmt das Tempo, und ihr Verhältnis, die Konditionszahl (condition number) $\kappa$, fasst zusammen, wie schwer das Problem ist.

Die Rechnung geht auf: $10 \times 0.9^{20} \approx 1.22$ und $10 \times (9/11)^{20} \approx 0.18$. Die Lehre für ein Projekt: Die Konvergenzgeschwindigkeit hängt von $\kappa$ ab, nicht von der Zahl der Parameter. Ein explodierender Verlust deutet auf einen Schritt über $2/\lambda_{\max}$ hin, ein Verlust, der sich nicht mehr bewegt, auf ein großes $\kappa$, und genau dort setzen die Normalisierung und die koordinatenweisen Schritte von Adam an.

Zurück zum Inhalt.

Normalisierung und Batch-Normalisierung, mit dem Gradienten, der sie durchquert

Jede Schicht sollte der nächsten Zahlen in einer vernünftigen Größenordnung übergeben; eine sorgfältige Initialisierung legt diese Skala zu Beginn fest, und die Batch-Normalisierung stellt sie im Training wieder her, Batch für Batch.

Eine Präaktivierung ist eine Summe von $d$ Produkten unabhängiger zentrierter Terme, ihre Varianz ist also $d\sigma^2$, wenn die Gewichte die Standardabweichung $\sigma$ haben. Mit 100 standardisierten Eingaben und $\sigma = 1$ ergibt die Simulation des Foliensatzes eine Varianz von etwa 120: Eine Sigmoidfunktion erhält dann Werte um ±10, geht in die Sättigung und lässt keinen Gradienten mehr durch. Wählt man $\sigma = 1/\sqrt{d}$, sinkt die Varianz wieder auf 1. Über $L$ Schichten wird die Varianz mit $(d\sigma^2)^L$ multipliziert; das ist die Seite des verschwindenden Gradienten, die sich schon im Vorwärtsdurchlauf zeigt.

Glorot und Bengio (2010) mitteln die Bedingung des Vorwärtsdurchlaufs ($1/d$) und die des Rückwärtsdurchlaufs ($1/N_h$, der Fan-out); die gleichverteilte Variante ihrer Regel hat dieselbe Varianz. He und Mitautoren (2015) verdoppeln die Varianz für ReLU, das die Hälfte der Einheiten abschaltet. Die Initialisierung legt die Skala allerdings nur zu Beginn fest. Die Batch-Normalisierung (batch norm) (Ioffe und Szegedy, 2015) zentriert und skaliert jede Einheit über den aktuellen Mini-Batch und lässt das Netz dann mit zwei gelernten Parametern $\gamma$ und $\beta$ neu skalieren, sodass es die Normalisierung dort rückgängig machen kann, wo das hilft.

Die klassische Frage im Vorstellungsgespräch betrifft den Rückwärtsdurchlauf. Die Falle besteht darin, dass jede Eingabe auf drei Wegen auf den Verlust wirkt: direkt, über den Batch-Mittelwert und über die Batch-Varianz, da beide von jedem $x_i$ abhängen. Addiert man die drei Wege und klammert aus, erhält man ein kompaktes Ergebnis: Der ausgehende Gradient ist der ankommende, minus sein Mittelwert, minus seine Projektion auf $\hat x$, im Maßstab $\gamma/\sigma_B$. Das entspricht der Invarianz der Schicht gegenüber Verschiebung und Umskalierung ihrer Eingaben.

Der Viererbatch des Foliensatzes: $x = (1, 2, 4, 5)$, $\gamma = 2$, $\beta = 0.5$, ankommender Gradient $g = (1, 0, -1, 2)$

1. Statistiken. Der Batch-Mittelwert ist 3 und die Varianz (geteilt durch $m = 4$) 2,5, also $\hat x = (-1.265, -0.632, 0.632, 1.265)$ und $y = (-2.030, -0.765, 1.765, 3.030)$.
2. Parameter. Der Gradient von $\beta$ ist die Summe der $g_i$, also 2; der Gradient von $\gamma$ ist $\sum g_i \hat x_i = 0.632$.
3. Eingaben. Der Skalierungsfaktor ist $2/(4\sqrt{2.5}) = 0.316$, und die Klammer liefert den Gradienten der Eingaben $(0.885, -0.506, -2.024, 1.644)$.
4. Probe. Autograd von PyTorch liefert dieselben vier Zahlen bis auf $10^{-4}$ genau, womit sich der Kreis zum Berechnungsgraphen schließt.

Zurück zum Inhalt.

Tiefe, der verschwindende Gradient und die Residualverbindung

Zusätzliche Schichten zerlegen die Eingabe in weit mehr Stücke als zusätzliche Neuronen, aber das Fehlersignal wird auf dem Weg nach unten schwächer, und ResNet behebt das, indem es die Eingabe jedes Blocks zu seiner Ausgabe addiert.

Ein ReLU-Netz ist stückweise affin, und jede verborgene Schicht faltet den Eingaberaum zusammen, was die Zahl der linearen Regionen vervielfacht, statt nur etwas hinzuzufügen (Pascanu, Montúfar und Bengio, 2014). Man nehme zwei Eingaben und insgesamt zwölf ReLU-Einheiten: In einer einzigen Schicht angeordnet, zerschneiden sie die Ebene in 79 Regionen, in drei Schichten zu je vier erzeugen sie mindestens 176.

Doch einfache Schichten zu stapeln scheitert. He, Zhang, Ren und Sun (2015) zeigten ein Netz mit 56 Schichten, dessen Fehler im Training höher lag als der eines Netzes mit 20 Schichten, obwohl es das flache Netz kopieren könnte, indem es seine zusätzlichen Schichten auf die Identität setzt: Die Kapazität ist vorhanden, der Optimierer findet sie nicht. Die Ursache ist ein Produkt. Der Gradient, der die erste Schicht erreicht, ist der Ausgabegradient mal eine Jacobi-Matrix pro Schicht, und mit einer Sigmoidfunktion beträgt jeder Faktor höchstens ein Viertel der Gewichtsnorm. Das ist das Problem des verschwindenden Gradienten (vanishing gradient).

Zehn Schichten mit Gewichten der Größenordnung 1 liefern unten also einen millionenfach kleineren Gradienten, und Faktoren über 1 lassen ihn stattdessen explodieren. Die Gegenmittel sind ReLU (ein Faktor von 0 oder 1), die Normalisierung und die Residualverbindung (residual connection): Jeder Block lernt eine Korrektur $F$ und addiert seine Eingabe wieder hinzu. Seine Jacobi-Matrix ist die Identität plus etwas, also enthält das Produkt immer einen Pfad der Norm 1. Initialisiert man die letzte Batch-Normalisierung jedes Blocks mit $\gamma = 0$, startet das Netz als Identität; so wurden für ImageNet 2015 Netze mit 152 Schichten trainiert.

DenseNet, U-Net und die Hilfsverluste von GoogLeNet sind Varianten desselben kurzen Wegs für den Gradienten, und jeder Transformer ist ein Stapel von Residualblöcken. Der Foliensatz schließt das Kapitel mit zwei Ergebnissen, die das klassische Bild der Überanpassung (Overfitting) erschüttern (Netze können sich auch an zufällige Labels anpassen; in großen Netzen sind die meisten lokalen Minima fast so gut wie das globale), und mit einem Raster aus fünf Fragen, um jede Modellkarte zu lesen: Tiefe und Breite, Aktivierung, Position der Normalisierung, Residualverbindungen und Verlustfunktion.

Zurück zum Inhalt.

Faltung: ein kleiner Filter, überall derselbe

Eine Faltungsschicht schiebt einen einzigen kleinen Detektor über das ganze Bild, braucht deshalb sehr wenige Gewichte und findet ein Muster, wo immer es auftaucht.

Ein dichtes Neuron betrachtet jedes Pixel mit einem eigenen Gewicht; ein Faltungsfilter betrachtet ein kleines Fenster und verwendet an jeder Position dieselben Gewichte. Auf zwei Annahmen beruht ein faltendes neuronales Netz (convolutional neural network, CNN): Nützliche Muster sind lokal (eine Kante passt in 3 × 3 Pixel), und sie bedeuten überall im Bild dasselbe. Der Foliensatz berechnet von Hand einen Filter für vertikale Kanten auf einem 4 × 4-Bild: Oben links ergibt die linke Spalte minus die rechte $(1 + 0 + 2) - (0 + 3 + 0) = 0$, keine Kante; ein Pixel weiter rechts ergibt sie $(2 + 1 + 1) - (1 + 1 + 0) = 2$.

Die geteilten Gewichte machen die Schicht genügsam. Sechs 3 × 3-Filter auf einem Farbbild kosten $3 \times 3 \times 3 \times 6 + 6 = 168$ Parameter, während eine dichte Schicht, die dieselben 32 × 32 × 3 Eingaben mit denselben 6 × 28 × 28 Ausgaben verbindet, etwa 14,5 Millionen bräuchte. Der Rechenaufwand bleibt beträchtlich, rund 127.000 Multiply-Add-Operationen für dieses eine kleine Bild, weil jeder Filter an jeder Position ausgewertet wird: Die Faltungen tragen die Rechenlast, die abschließenden dichten Schichten die Parameter, und Global Average Pooling spart den Großteil dieser Parameter ein.

Das Bildstück, von dem eine tiefe Einheit abhängt, heißt rezeptives Feld (receptive field); es wächst pro Schicht um $k - 1$, multipliziert mit den darunter angesammelten Schrittweiten. Drei gestapelte 3 × 3-Schichten sehen 7 Pixel, wie ein einziger 7 × 7-Filter, mit 27 statt 49 Gewichten und zwei zusätzlichen Nichtlinearitäten; auf diesem Argument wurde VGG aufgebaut. Die Geschichte reicht vom Neocognitron von Fukushima (1980) und LeCuns LeNet-5, das Bankschecks las (1998), bis zu AlexNet im Jahr 2012, als der Top-5-Fehler auf ImageNet von 26 % auf 15 % fiel, und weiter zu ResNet und den Vision Transformers. Typische Anwendungen in Unternehmen sind das Lesen von Dokumenten (KYC-Akten, Rechnungen), Satellitenbilder und das Fine-Tuning eines vortrainierten Netzes mit einigen tausend hauseigenen Bildern.

Zurück zum Inhalt.

Sequenzen und Aufmerksamkeit: vom LSTM zum Transformer

Ein rekurrentes Netz liest eine Sequenz Schritt für Schritt und führt eine laufende Zusammenfassung mit, das LSTM kopiert sie weiter, ohne dass sie verblasst, und die Aufmerksamkeit ersetzt sie durch einen gewichteten Blick auf jedes Element.

Ein rekurrentes neuronales Netz (recurrent neural network, RNN) aktualisiert einen verborgenen Zustand fester Größe aus dem vorherigen Zustand und der aktuellen Eingabe, mit denselben drei Matrizen bei jedem Schritt. In der Zeit ausgerollt, ist es ein gewöhnliches tiefes Netz, dessen Schichten ihre Gewichte teilen, trainiert mit Backpropagation durch die Zeit. Der Gradient von Schritt $T$ zurück zu Schritt 1 ist wieder ein Produkt von Jacobi-Matrizen, nun aber jedes Mal mit derselben Matrix $V$, sodass sich seine Norm wie eine Potenz von $\|V\|$ verhält. In der Praxis lernt ein einfaches RNN keine Abhängigkeiten über mehr als zehn oder zwanzig Schritte. Gradient Clipping fängt die Explosion ab; gegen das Verblassen hilft eine andere Zelle.

Das LSTM (Hochreiter und Schmidhuber, 1997) führt einen Speicher $c$, der durch Addition aktualisiert und von sigmoidförmigen Gates zum Vergessen, Schreiben und Ausgeben gesteuert wird. Mit einem vorherigen Speicherwert von 3 und einem Kandidaten von −1 kopieren die Gates $f = 1, i = 0$ die Vergangenheit ($\tanh 3 \approx 0.995$), $f = 0, i = 1$ ersetzen sie ($\tanh(-1) \approx -0.762$), und $f = i = 0.5$ mischen beides ($\tanh 1 \approx 0.762$). Ist das Forget-Gate offen, überquert der Gradient einen Zeitschritt multipliziert mit einer Zahl nahe 1: der additive Pfad, den ResNet für die Tiefe wiederentdecken sollte. Bei der Einbettung (embedding) von Wörtern (word2vec, 2013) wird jedes Wort zu einer gelernten Zeile einer Tabelle, sodass Wörter, die in ähnlichen Kontexten vorkommen, nahe beieinander landen.

Der Aufmerksamkeitsmechanismus (attention) ist ein weiches Nachschlagen: Für eine Anfrage (Query) bewertet man jedes Element nach seiner Ähnlichkeit, macht aus den Scores per Softmax Gewichte und gibt den gewichteten Mittelwert zurück. Im Beispiel des Foliensatzes sind die drei Elemente $(1, 0)$, $(0, 1)$ und $(1, 1)$, und die Anfrage ist das dritte.

Bei der Self-Attention ist jedes Wort der Reihe nach die Anfrage, und drei gelernte Projektionen lassen es drei Rollen spielen: fragen, gefunden werden, gelesen werden. Die Division durch $\sqrt{d_k}$ ist wieder das Varianzargument aus dem Abschnitt über die Normalisierung: Ein Skalarprodukt aus $d_k$ Termen mit Varianz 1 hat die Varianz $d_k$, und wenn seine Eingaben groß sind, kollabiert die Softmax-Funktion zu einem harten Argmax, dessen Gradient null ist. Das Satzbeispiel des Foliensatzes zeigt den Gewinn: Neben „orange“ rückt der Vektor von „Apple“ in Richtung der Frucht, neben „Microsoft“ in Richtung des Unternehmens, was feste Einbettungen nicht leisten können. Der Aufwand wächst quadratisch mit der Kontextlänge. Das vollständige Rechenbeispiel mit allen Matrizen steht im Artikel Aufmerksamkeit, Schritt für Schritt.

import torch, math

def attention(Q, K, V):
    # Scores durch sqrt(d_k) geteilt, Softmax pro Zeile, dann gewichteter Mittelwert von V
    w = torch.softmax(Q @ K.T / math.sqrt(K.shape[1]), dim=-1)
    return w @ V

E = torch.tensor([[1., 0.], [0., 1.], [1., 1.]])
print(torch.softmax(E @ E[2], dim=0))   # Gewichte ohne Skalierung: 0.212, 0.212, 0.576
print(attention(E, E, E)[2])           # skalierte Ausgabe: etwa (0.752, 0.752)

Zurück zum Inhalt.

Generative Modelle: Autoencoder, VAE und GAN

Generative Modelle lernen, wie normale Daten aussehen, entweder um neue Stichproben daraus zu ziehen oder um zu markieren, was nicht passt, und VAE und GAN erreichen dieses Ziel auf zwei sehr verschiedenen Wegen.

Ein Autoencoder komprimiert $x$ zu einem kurzen Code $z$ und rekonstruiert es daraus; der Engpass ist zwingend, da sonst das Kopieren der Eingabe eine perfekte und nutzlose Lösung wäre. Mit linearen Schichten und quadratischem Verlust findet er die Hauptkomponentenanalyse wieder. Auf normalen Transaktionen trainiert, rekonstruiert er schlecht, was er nie gesehen hat, und so wird der Rekonstruktionsfehler zu einem Signal für Betrug oder Störungen; seine Alarmschwelle wählt man wie jede Score-Schwelle, indem man Fehlalarme gegen übersehene Fälle abwägt. Generieren kann er allerdings nicht: Die Codes füllen keinen regelmäßigen Bereich aus, sodass ein zufälliges $z$ zu nichts Sinnvollem decodiert wird.

Ein variationeller Autoencoder (variational autoencoder, VAE) (Kingma und Welling, 2013) lässt den Encoder eine Normalverteilung über $z$ zurückgeben und legt eine Standardnormalverteilung als A-priori-Verteilung auf die Codes. Die Likelihood selbst ist nicht berechenbar, also maximiert das Modell stattdessen die untere Evidenzschranke (evidence lower bound, ELBO), die sich in vier Zeilen herleiten lässt: über $z$ integrieren, mit der Dichte des Encoders multiplizieren und durch sie dividieren, die Jensen-Ungleichung auf den konkaven Logarithmus anwenden und eine Kullback-Leibler-Divergenz erkennen.

Der erste Term will, dass der Code alles über $x$ sagt, der zweite, dass er nichts Besonderes sagt; ihr Kompromiss ist der Engpass in probabilistischer Form. Die Probe des Foliensatzes für die geschlossene Form: Für eine Koordinate mit $\mu = 1$ und $\sigma = 0.5$ beträgt die Divergenz $\tfrac12(1 + 0.25 - 1 - \ln 0.25) \approx 0.818$. Das Training per Gradient nutzt die Reparametrisierung $z = \mu(x) + \sigma(x)\xi$ mit standardnormalverteiltem Rauschen $\xi$, damit der Zufall außerhalb der Parameter liegt.

Ein generatives gegnerisches Netzwerk (generative adversarial network, GAN) (Goodfellow und Mitautoren, 2014) schreibt überhaupt keine Dichte auf. Ein Generator verwandelt Rauschen in Stichproben, ein Diskriminator ist ein gewöhnlicher Klassifikator für echt oder gefälscht, trainiert mit der Log-Likelihood, und beide spielen ein Min-Max-Spiel. Bei festem Generator ergibt sich der beste Diskriminator, indem man den Integranden punktweise maximiert.

In der Illustration des Foliensatzes erhält ein Punkt, an dem die Datendichte 0,3 und die des Generators 0,1 beträgt, $D^{*} = 0.75$, und im Gleichgewicht ist der Wert des Spiels $-\ln 4 \approx -1.386$. Gegen den besten Diskriminator minimiert der Generator also eine Jensen-Shannon-Divergenz, die nur dann null ist, wenn er die Verteilung der Daten reproduziert. In der Praxis neigt der VAE zu unscharfen Ergebnissen und das GAN dazu, Moden auszulassen; Wasserstein-Verluste und spektrale Normalisierung stabilisieren GANs, die FID misst die Qualität, ergänzend zum menschlichen Auge. Seit 2021 haben Diffusionsmodelle bei Bildern, Ton und Video die Führung übernommen, während GANs und VAEs in Werkzeugen für tabellarische synthetische Daten wie CTGAN weiterleben, die in der Finanzbranche genutzt werden, um einen Datensatz zu teilen, ohne Kunden offenzulegen, und um Stressszenarien zu bauen.

Zurück zum Inhalt.

Das Wichtigste in Kürze

1. Backpropagation durchläuft den Berechnungsgraphen rückwärts: Jeder Knoten multipliziert den Gradienten mit seiner lokalen Ableitung, und Wege, die zusammentreffen, werden addiert.
2. Wer den quadratischen Fehler oder die Kreuzentropie gegenüber einem 0/1-Label minimiert, schätzt dessen Wahrscheinlichkeit; die Kreuzentropie lernt schneller, wenn ein Neuron selbstsicher danebenliegt, und die Kalibrierung muss trotzdem geprüft werden.
3. Der Gradientenschritt wird von der steilsten Richtung des Verlusts begrenzt und sein Tempo von der flachsten bestimmt, also hängt alles von der Konditionszahl ab.
4. Halten Sie die Aktivierungen Schicht für Schicht bei Varianz 1; die Batch-Normalisierung lernt ihre Skala und Verschiebung und gibt einen Gradienten nach unten weiter, der zentriert und von den normalisierten Eingaben dekorreliert ist.
5. Gradienten durchlaufen die Schichten per Multiplikation, was sie verschwinden oder explodieren lässt; die Residualverbindung fügt einen Identitätspfad hinzu, der sie immer durchlässt.
6. Eine Faltung ist ein geteilter lokaler Filter mit wenigen Parametern und einem rezeptiven Feld, das mit der Tiefe wächst; ein LSTM kopiert seinen Speicher durch eine Addition weiter.
7. Aufmerksamkeit ist ein Mittelwert der Werte, gewichtet mit einem Softmax der Ähnlichkeit zwischen Anfrage und Schlüssel; der VAE maximiert eine Schranke der Likelihood, das GAN trainiert einen Generator gegen einen Klassifikator.

Glossar

Berechnungsgraph (computational graph)

Der gerichtete azyklische Graph der elementaren Operationen, der beim Vorwärtsdurchlauf aufgezeichnet und rückwärts durchlaufen wird, um die Gradienten zu erhalten.

automatische Differentiation (automatic differentiation)

Exakte Berechnung von Ableitungen durch Anwendung der Kettenregel Knoten für Knoten; der Rückwärtsmodus liefert alle Gradienten einer Ausgabe in einem einzigen Rückwärtsdurchlauf.

Konditionszahl (condition number)

Das Verhältnis des größten zum kleinsten Eigenwert der Hesse-Matrix; sie bestimmt die Konvergenzrate des Gradientenabstiegs.

Batch-Normalisierung (batch norm)

Eine Schicht, die jede Einheit mit den Statistiken des Mini-Batches zentriert und skaliert und sie dann mit zwei gelernten Parametern neu skaliert.

Problem des verschwindenden Gradienten (vanishing gradient)

Das Schrumpfen des Gradienten, wenn er auf dem Rückweg mit einer Jacobi-Matrix pro Schicht oder pro Zeitschritt multipliziert wird.

Residualverbindung (residual connection)

Die Addition der Eingabe eines Blocks zu seiner Ausgabe, sodass der Block eine Korrektur lernt und der Gradient einen direkten Pfad behält.

faltendes neuronales Netz (convolutional neural network, CNN)

Ein Netz aus kleinen Filtern, deren Gewichte über alle Positionen eines Bildes oder Signals geteilt werden.

rezeptives Feld (receptive field)

Der Bereich der Eingabe, der eine bestimmte Einheit beeinflusst; er wächst mit den Filtergrößen und den angesammelten Schrittweiten.

rekurrentes neuronales Netz (recurrent neural network, RNN)

Ein Netz, das bei jedem Schritt einer Sequenz mit denselben Gewichten einen verborgenen Zustand aktualisiert.

Einbettung (embedding)

Ein gelernter Vektor, der eine Kategorie darstellt, etwa ein Wort, gespeichert als Zeile einer trainierbaren Tabelle.

Aufmerksamkeitsmechanismus (attention)

Ein gewichteter Mittelwert von Werten, dessen Gewichte ein Softmax der Ähnlichkeiten zwischen einer Anfrage und Schlüsseln sind.

untere Evidenzschranke (evidence lower bound, ELBO)

Die berechenbare untere Schranke der Log-Likelihood, die ein VAE maximiert: Rekonstruktion minus ein Kullback-Leibler-Term.

variationeller Autoencoder (variational autoencoder, VAE)

Ein Autoencoder, dessen Encoder eine Verteilung über die Codes zurückgibt, trainiert auf der ELBO, und aus dem sich neue Stichproben ziehen lassen.

generatives gegnerisches Netzwerk (generative adversarial network, GAN)

Ein Generator und ein Diskriminator, die gegeneinander trainiert werden; im Optimum reproduziert der Generator die Verteilung der Daten.

Die anderen Notizen des Kurses

Eine öffentliche Zusammenfassung pro Foliensatz, in der Reihenfolge des Kurses.

Zurück: Python-Code für jedes ML-ModellWeiter: ML-Projekte mit offenen Daten nach Branche

1. EinführungKI-Winter, Arbeitsmarkt und Methode
2. WerkzeugeKaggle, GitHub, Python: die Werkzeuge
3. Sitzung 1Projektrahmen und kleinste Quadrate
4. Sitzung 2Maximum Likelihood und logistische Regression
5. Sitzung 3Gradientenabstieg, Ridge und Lasso
6. Sitzung 4Entscheidungsschwelle und reproduzierbares ML
7. HausaufgabeML-Projekt abstecken: der Projektsteckbrief
8. Sitzung 5Kernel, SVM und Entscheidungsbäume
9. Sitzung 6Random Forests, Boosting, ehrlicher Vergleich
10. Sitzung 7SHAP, Fairness, PCA und Clustering
11. HausaufgabeEin einfaches Modell mit vollständiger Methode
12. Sitzung 8Neuronale Netze, Drift, konforme Vorhersage
13. HausaufgabeEin ausgeliefertes Machine-Learning-Projekt
14. Sitzung 9Ein Machine-Learning-Projekt verteidigen
15. ReferenzProjekt zum Kreditausfallscore
16. ReferenzAktienrenditen: XGBoost und Sentiment
17. ReferenzPython-Code für jedes ML-Modell
18. ReferenzDeep Learning, das Wesentliche
19. ReferenzML-Projekte mit offenen Daten nach Branche
20. ReferenzHandbuch für Daten- und KI-Fachleute
21. ReferenzData Engineering, SRE und Cloud
22. ReferenzPanorama der Machine-Learning-Modelle

Alle Notizen als Leseliste

Aufmerksamkeit und Transformer, Schritt für Schritt

Über diese Notizen

Vom Dozenten auf Grundlage der Folien verfasst, als öffentliche Zusammenfassung: die Kernideen, die Formeln und ein durchgerechnetes Beispiel. Die Übungen, ihre Lösungen, die Tests und die Bewertung bleiben im Foliensatz, für die Studierenden des Kurses.

Stand: 16. Oktober 2026.