Neuronale Netze: von Perzeptronen zu Deep Learning

Am 10. März 2016, im zweiten Spiel einer Fünf-Partien-Serie in Seoul, platzierte eine Maschine namens AlphaGo einen schwarzen Stein auf der fünften Linie des Bretts. Der Zug war so seltsam, dass die menschlichen Kommentatoren ihn für einen Fehler hielten. Ein Profi sagte laut, dass ein Anfänger für diesen Zug getadelt würde. Lee Sedol — 18-facher Weltmeister im Go — stand auf und verließ den Raum, um sich zu sammeln.

Es war kein Fehler. Fünfzig Züge später war dieser Stein — inzwischen berühmt als „Zug 37“ — die Angel, um die sich die ganze Partie drehte. AlphaGo gewann. Lee Sedol, betrachtet als einer der größten lebenden Spieler, verlor die Serie 4:1. Und hier ist der Teil, der zählt: Kein Mensch lehrte AlphaGo diesen Zug. Er stand in keinem Lehrbuch. Die Maschine hatte ihn selbst entdeckt, indem sie Millionen Spiele gegen sich selbst spielte und Milliarden winziger interner Zahlen anpasste, bis ein Muster auftauchte, das nie ein Mensch gesehen hatte.

Go hat mehr mögliche Brettpositionen, als es Atome im beobachtbaren Universum gibt. Man kann es nicht per Brute Force lösen. Man kann keine Regeln dafür aufschreiben. Der einzige Weg, es auf übermenschlichem Niveau zu spielen, ist es zu lernen — und das, was das Lernen tat, war ein neuronales Netz: ein Stapel einfacher mathematischer Einheiten, die, gegeben genug Daten und genug Anpassung, Struktur finden können, die kein Mensch vollständig artikulieren kann.

Dieselbe Maschinerie — dieselben gewichteten Summen, derselbe Trainingsloop, dieselben Gradienten-Anstöße — treibt das Sprachmodell an, mit dem du sprichst, das System, das betrügerische Kartentransaktionen markiert, und die Modelle, die quantitative Fonds heute auf Finanzmärkte richten. Diese Lektion handelt davon, was tatsächlich in dieser Box passiert.

Jedes neuronale Netz — von einem einfachen Spamfilter bis zu GPT und AlphaGo — stammt von einer einzigen Idee ab: dem Perzeptron, erfunden von Frank Rosenblatt 1958. Es ist ein mathematisches Modell, das locker von einem biologischen Neuron inspiriert ist. Ein echtes Neuron empfängt elektrische Signale über seine Dendriten, akkumuliert sie im Zellkörper und feuert nur dann ein Signal durch sein Axon, wenn die kombinierte Eingabe eine Schwelle überschreitet. Das Perzeptron tut dasselbe, nur mit Zahlen statt Spannung.

Ein Perzeptron nimmt einen Vektor von Eingaben x, multipliziert jede Eingabe mit einem gelernten Gewicht w, summiert die Produkte, fügt einen Bias-Term b hinzu, der die Schwelle verschiebt, und leitet das Ergebnis durch eine Aktivierungsfunktion. Überschreitet das Ergebnis die Latte, „feuert“ das Neuron; sonst bleibt es ruhig. Das Ganze ist ein kompakter Ausdruck: Ausgabe = f(w·x + b).

Stell dir die Gewichte als Lautstärkeregler vor. Jede Eingabe kommt mit einer gewissen Lautstärke an, und das Gewicht entscheidet, wie sehr diese Eingabe für dieses bestimmte Neuron zählt. Ein Neuron, das lernt, einen betrügerischen Trade zu erkennen, könnte das Gewicht für „Transaktionsgröße relativ zur Kontohistorie“ hochdrehen und das Gewicht für „Tageszeit“ herunterdrehen. Lernen ist im Kern nichts Glanzvolleres als diese Regler auf die richtigen Einstellungen zu drehen.

Ein einzelnes Perzeptron hat eine harte Grenze: Es kann Daten nur mit einer geraden Linie trennen (oder, in höheren Dimensionen, einer flachen Hyperebene). Es kann „ist dieser Punkt über oder unter der Linie?“ beantworten, aber nicht „ist dieser Punkt innerhalb der gekrümmten Region?“. Das historische Beispiel ist das XOR-Problem — ein Muster, das ein einzelnes Perzeptron beweisbar nicht lernen kann, eine Einschränkung, die dazu beitrug, die KI-Finanzierung in den 1970ern jahrelang einzufrieren. Der Ausweg ist im Nachhinein fast absurd einfach: Staple viele Perzeptronen in Schichten und füge eine nichtlineare Aktivierung zwischen ihnen ein. Tu das, und das resultierende Netz kann den Raum in beliebig komplexe Formen biegen, falten und schneiden.

Ein Neuron ist ein Regler. Ein nützliches Netz besteht aus Tausenden davon, organisiert in Schichten, die Informationen wie in einer Eimerkette nach vorne weitergeben.

• Eingabeschicht — wo deine rohen Features eintreten: Pixel eines Bildes, Wörter eines Satzes, oder für ein Trading-Modell Dinge wie Preis, Volumen, Volatilität und Orderbuch-Imbalance.
• Verborgene Schichten — die Schichten dazwischen, wo die eigentliche Arbeit passiert. Jede Schicht nimmt die Ausgaben der vorherigen und kombiniert sie neu zu neuen, abstrakteren Features.
• Ausgabeschicht — die finale Antwort: eine Wahrscheinlichkeit, eine Preisprognose, ein Klassenlabel.

Das Wort „deep“ in Deep Learning bedeutet schlicht viele verborgene Schichten. Und Tiefe kauft dir etwas Spezifisches: eine Hierarchie von Features. In einem Bildnetz erkennt die erste Schicht Kanten, die nächste setzt Kanten zu Formen zusammen, die nächste setzt Formen zu Objekten zusammen. Niemand programmierte „Kantendetektor“ oder „Augendetektor“ — diese Konzepte entstehen aus dem Training. Das Netz erfindet sein eigenes Zwischenvokabular.

Es gibt hier ein schönes theoretisches Ergebnis, den Universal Approximation Theorem: Ein Netz mit auch nur einer einzigen verborgenen Schicht kann, gegeben genug Neuronen, jede stetige Funktion mit beliebiger Genauigkeit approximieren. Mit anderen Worten, das richtige Netz kann im Prinzip jedes Muster darstellen, das in deinen Daten existiert. Der Haken — und ein großer — ist, dass „im Prinzip“ viel Arbeit leistet. Das Theorem verspricht, dass ein solches Netz existiert; es sagt nichts darüber aus, ob du es finden kannst, ob du genug Daten hast, um es festzunageln, oder ob das Muster, dem du nachjagst, überhaupt real ist. In signalarmen Domänen wie Finance ist diese Kluft zwischen „darstellbar“ und „lernbar“ genau dort, wo die meisten Modelle sterben.

Hier ist eine Tatsache, die Menschen überrascht: Ohne Aktivierungsfunktionen ist Tiefe wertlos. Wäre jede Schicht eine einfache gewichtete Summe, wäre das Stapeln von zehn Schichten mathematisch identisch mit einer einzigen Schicht — eine Kette linearer Operationen kollabiert zu einer einzigen linearen Operation. Man hätte ein Vermögen an Rechenleistung ausgegeben, um eine glorifizierte Gerade zu bauen. Aktivierungsfunktionen sind der nichtlineare Knick, der zwischen Schichten eingefügt wird und dem Netz erlaubt, sich zu biegen — und dieses Biegen ist es, was es mächtig macht.

Die Aktivierungen, die jeder Praktiker kennen sollte:

• Sigmoid — σ(x) = 1/(1+e⁻ˣ). Presst jede Eingabe in (0, 1), was sich natürlich als Wahrscheinlichkeit lesen lässt. Großartig für eine binäre Ausgabe, aber eine schlechte Wahl innerhalb verborgener Schichten: Bei großen positiven oder negativen Eingaben flacht die Kurve ab, ihr Gradient geht gegen nahezu null, und das Lernen kommt zum Stillstand — das Vanishing-Gradient-Problem.
• Tanh — gibt Werte in (−1, 1) aus und ist nullzentriert, was die Optimierung unterstützt. Sättigt immer noch an den Extremen, aber weniger scharf als Sigmoid.
• ReLU — f(x) = max(0, x). Der moderne Standard für verborgene Schichten. Sie ist lächerlich einfach, günstig zu berechnen und hält einen gesunden Gradienten für alle positiven Eingaben aufrecht. Ihr Fehler ist das „Dying ReLU“: ein Neuron, das dazu gedrängt wird, immer null auszugeben, kann permanent inert werden.
• Leaky ReLU — f(x) = max(0.01x, x). Lässt für Negatives ein kleines Rinnsal Gradient durch, was Neuronen davor bewahrt zu sterben.
• GELU — ein glatter, probabilistischer Cousin von ReLU, der der Standard innerhalb von Transformern wie BERT und GPT ist.

Bisher haben wir ein Netz voller Gewichte. Aber woher kommen die richtigen Gewichtswerte? Niemand tippt sie ein — es sind Millionen. Sie werden durch einen Feedback-Loop entdeckt, der im Kern organisiertes Trial and Error ist, mit Kalkül, das die Buchhaltung übernimmt.

Schritt eins ist der Forward Pass: füttere ein Beispiel ein, lasse es durch die Schichten fließen und lies eine Vorhersage ab. Schritt zwei ist zu messen, wie falsch diese Vorhersage war, mit einer Loss-Funktion. Für die Vorhersage einer Zahl (eines Preises) mittelt Mean Squared Error die quadrierte Lücke zwischen Vorhersage und Wahrheit. Für Klassifikation misst Cross-Entropy, wie weit die vorhergesagten Wahrscheinlichkeiten von der richtigen Antwort entfernt sitzen. Ein hoher Loss bedeutet „sehr falsch“; das gesamte Ziel des Trainings ist es, diese Zahl nach unten zu drücken.

Schritt drei ist der clevere Teil: Backpropagation. Mit der Kettenregel des Kalküls arbeitet sich der Algorithmus vom Loss rückwärts durch jede Schicht und berechnet für jedes einzelne Gewicht einen Gradienten — die Antwort auf „wenn ich dieses eine Gewicht ein bisschen nach oben stoße, geht der Fehler nach oben oder unten, und um wie viel?“ Das ist der Trick, der den KI-Winter auftaute. Backprop, in den 1980ern popularisiert, machte es möglich, Verantwortung effizient über Millionen von Gewichten zu verteilen, statt zu raten.

Schritt vier ist Gradient Descent: stoße jedes Gewicht einen kleinen Schritt in die Richtung, die den Loss reduziert, mit der Regel w = w − α × ∂L/∂w. Stell dir vor, du stehst auf einem nebligen Hügel und versuchst, den Talboden zu erreichen; du kannst den Boden nicht sehen, aber du kannst unter deinen Füßen fühlen, welche Richtung bergab geht, also machst du einen Schritt in diese Richtung und wiederholst. Die Learning Rate α ist deine Schrittlänge, und sie ist wohl der wichtigste Regler im gesamten System. Zu groß, und du hüpfst über das Tal hinweg und prallst ewig herum; zu klein, und du kriechst eine Ewigkeit dahin oder bleibst auf halbem Weg in einem Graben stecken.

Zwei Verfeinerungen, denen du sofort begegnest. Mini-Batches: statt nach jedem einzelnen Beispiel zu aktualisieren (verrauscht) oder nur nach dem gesamten Datensatz (langsam), aktualisierst du nach einem kleinen Batch — typischerweise 32 bis 256 Beispiele —, was stabil, GPU-freundlich und in der Praxis der Sweet Spot ist. Und Adam: ein intelligenterer Optimierer, der jedem Gewicht seine eigene adaptive Schrittlänge gibt und Momentum hinzufügt, um verrauschte Gradienten zu glätten. Adam ist der vernünftige Standardausgangspunkt für fast jedes Projekt — obwohl du in Finance, mit seinem niedrigen Signal-Rausch-Verhältnis, immer noch die Learning Rate, den Weight Decay und den Stopppunkt von Hand tunen musst.

Hier ist der Fehlermodus, der mehr finanzielle Modelle zerstört als jeder andere. Ein neuronales Netz ist ein so flexibler Funktions-Anpasser, dass es, gegeben die Chance, deine Trainingsdaten schlicht auswendig lernen wird — einschließlich all des Zufallsrauschens, der Einmal-Flukes und der Zufälle, die sich nie wiederholen werden. Es punktet wunderbar auf den Daten, die es gesehen hat, und versagt in dem Moment, in dem es auf irgendetwas Neues trifft. Das ist Overfitting, und in Märkten — wo das echte Signal schwach und das Rauschen ohrenbetäubend ist — ist es das Standardergebnis, nicht die Ausnahme. Die Werkzeuge, die es bekämpfen, heißen Regularisierung.

Dropout ist das beliebteste. Während jedes Trainingsschritts hat jedes Neuron eine Wahrscheinlichkeit p (oft 0.2–0.5), vorübergehend abgeschaltet zu werden. Gezwungen zu arbeiten, auch wenn zufällige Teammitglieder ständig verschwinden, lernt das Netz, sein Wissen über viele Neuronen zu verteilen, statt alles auf ein paar fragile zu setzen — ein Ensemble-Effekt, eingebacken in ein einziges Modell. Zum Vorhersagezeitpunkt schalten sich alle Neuronen wieder ein, entsprechend skaliert.

L1- und L2-Strafen fügen dem Loss eine Steuer auf große Gewichte hinzu. L2 (Weight Decay) entmutigt jedes einzelne Gewicht, zu groß zu werden, und verteilt den Einfluss gleichmäßig. L1 ist schärfer: Es treibt nutzlose Gewichte aktiv bis auf exakt null, und führt automatische Feature-Selektion durch. In einem finanziellen Datensatz, wo die meisten deiner hundert Features Rauschen sind, kann L1 leise die Handvoll finden, die tatsächlich Signal tragen.

Batch Normalization skaliert die Ausgaben jeder Schicht auf einen stabilen Mittelwert und eine stabile Varianz um, was das Training stabilisiert und höhere Learning Rates erlaubt. Early Stopping ist der einfachste und zuverlässigste Schutz von allen: beobachte den Fehler auf einem zurückgehaltenen Validierungssatz, und in dem Moment, in dem er anfängt hochzukriechen, während der Trainingsfehler weiter fällt, stoppe — dieser Kreuzungspunkt ist genau der Moment, in dem das Netz vom Lernen von Mustern zum Auswendiglernen von Rauschen umschaltet.

Einfache Feedforward-Netze behandeln jede Eingabe als unstrukturierte Zahlentüte. Aber viele echte Daten haben Struktur — ein Bild hat räumliches Layout, eine Preisreihe hat zeitliche Reihenfolge — und zwei spezialisierte Architekturen nutzen diese Struktur direkt aus.

Convolutional Neural Networks (CNNs) wurden für Bilder gebaut. Statt jedes Pixel mit jedem Neuron zu verbinden, schiebt ein CNN kleine Filter über die Eingabe und jagt nach lokalen Mustern — hier eine Kante, dort eine Textur — und nutzt denselben Filter überall wieder. Frühe Schichten erfassen Kanten; tiefere Schichten setzen sie zu Formen und Objekten zusammen. In Finance haben Forscher CNNs auf Folgendes gerichtet:

• Candlestick-Chart-Bilder — Chart-Lesen als visuelle Mustererkennungsaufgabe umgedeutet.
• Orderbuch-Heatmaps — Angebots-/Nachfrage-Imbalancen in Depth-of-Market-Schnappschüssen erkennen.
• 1D-Convolutions über rohe Preissequenzen — kurze zeitliche Motive lernen, so wie ein Bild-CNN räumliche lernt.

Recurrent Neural Networks (RNNs) sind für Sequenzen gebaut. Sie verarbeiten einen Zeitschritt nach dem anderen, während sie einen Hidden State — ein laufendes Gedächtnis — von jedem Schritt zum nächsten mittragen. Theoretisch macht das sie ideal für Zeitreihen. In der Praxis sind einfache RNNs durch das Vanishing-Gradient-Problem über lange Sequenzen gelähmt: Signal von vielen Schritten zuvor schrumpft auf dem Rückweg gegen null, sodass das Netz die entfernte Vergangenheit schlicht vergisst.

Long Short-Term Memory (LSTM)-Netze beheben das mit einer kleinen Menge lernbarer Gates — Forget, Input und Output —, die bei jedem Schritt entscheiden, was aus dem Gedächtnis gelöscht, was hineingeschrieben und was ausgelesen wird. Diese Gating-Mechanik erlaubt es einem LSTM, relevante Informationen über Hunderte von Schritten zu behalten, weshalb es zum Arbeitstier für die Modellierung finanzieller Zeitreihen wurde, wo ein Ereignis von gestern den heutigen Preis immer noch bewegt.

import torch.nn as nn

class PricePredictor(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim,
                            num_layers, batch_first=True,
                            dropout=0.2)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

Auf einer Plattform wie GaiaEx, wo WebSocket-Feeds kontinuierliche Preis- und Orderbuch-Daten streamen, kann ein LSTM diese Sequenz natürlich aufnehmen. Allerdings ist das Feld größtenteils weitergezogen: Transformer — die Architektur hinter modernen Sprachmodellen — erreichen oder schlagen jetzt LSTMs bei vielen Sequenzaufgaben, indem sie „Attention“ nutzen, um alle Zeitschritte auf einmal zu betrachten, statt sie einen nach dem anderen abzumarschieren.

Neuronale Netze sind spektakuläre Musterfinder. Aber ehrliche Aufklärung bedeutet zu benennen, wo sie versagen — und im Trading versagen sie auf teure Weise.

• Sie finden Muster, auch wenn keine existieren. Gib einem tiefen Netz Rauschen, und es wird es selbstsicher anpassen. Märkte sind größtenteils Rauschen, also liegt die Beweislast bei dir zu zeigen, dass ein Muster real und dauerhaft ist — nicht nur in den Daten des letzten Jahres präsent.
• Sie sind Black Boxes. Ein Modell kann genau sein und dir trotzdem nicht sagen können, warum. Wenn es plötzlich Geld verliert, gibt es oft keine saubere Erklärung und keine offensichtliche Lösung. Für risikotragendes Kapital ist „ich weiß nicht, warum es das getan hat“ eine ernste Verbindlichkeit.
• Sie sind hungrig und fragil. Deep Learning glänzt mit Millionen sauberer Beispiele. Finanzgeschichte ist kurz, nicht-stationär und verrauscht — das Regime, das dein Modell trainierte, kann schlicht aufhören zu existieren, ein Problem namens Distribution Shift.
• Sie schlagen einfachere Modelle nicht kostenlos. Auf den tabellarischen, feature-basierten Daten, die in Finance üblich sind, übertreffen Gradient-Boosted-Trees wie XGBoost häufig neuronale Netze, während sie schneller trainieren und leichter zu interpretieren sind. Komplexität ist eine Kosten, keine Tugend.
• Sie können angegriffen werden. Winzige, absichtliche Störungen an einer Eingabe können die Ausgabe eines Netzes umkippen — ein Adversarial Example —, was überall wichtig ist, wo ein Gegner beeinflussen kann, was dein Modell sieht.

Das Training neuronaler Netze ist rechenintensiv — überwiegend Matrixmultiplikationen —, und die Hardware, auf der du es ausführst, verändert deine Iterationsgeschwindigkeit von „über Nacht“ zu „über einen Kaffee“.

GPUs sind der Standard. Ihre Tausenden Kerne führen alle dieselbe Operation gleichzeitig auf unterschiedlichen Daten aus, was genau der Form der Mathematik neuronaler Netze entspricht. Ein Modell, das auf einer CPU 8 Stunden kriecht, kann auf einer modernen GPU in 15 Minuten fertig sein. NVIDIA dominiert: Consumer-Karten (eine RTX-Klasse-GPU) sind gut zum Lernen, während Rechenzentrums-Karten (A100, H100) und Cloud-Instanzen Produktions-Training in großem Maßstab bewältigen. TPUs, Googles maßgeschneiderte Chips für Tensor-Mathematik, glänzen bei sehr großen Modellen über Google Cloud, aber GPUs bleiben der praktische Standard für die meisten Praktiker dank breiterer Software-Unterstützung.

Du musst nichts kaufen, um anzufangen. Google Colab gibt kostenlose GPU-Zeit, die reichlich zum Lernen und Prototypen ist; miete Cloud-GPUs bei Bedarf, während deine Modelle wachsen; kaufe dedizierte Hardware erst, sobald du täglich trainierst und die Cloud-Rechnung es rechtfertigt.

Ein vernünftiger Lernpfad von hier aus:

• Beginne mit einem einfachen Feedforward-Netz auf ein paar konstruierten Features — schnell zu trainieren, leicht zu debuggen und eine ehrliche Baseline.
• Probiere ein 1D-CNN auf rohen Preissequenzen und vergleiche es Kopf an Kopf mit dieser Baseline.
• Baue ein LSTM, das Sequenzen von Candlestick-Daten aus GaiaEx' API konsumiert.
• Studiere Attention und Transformer — zunehmend die Architektur der Wahl für Sequenzen.
• Vor allem, stelle dein tiefes Modell immer gegen eine Gradient-Boosting-Baseline wie XGBoost. Wenn das neuronale Netz das einfachere Modell out-of-sample auf deinen tabellarischen Finanzdaten nicht schlagen kann, versende das einfachere Modell und geh weiter.

Derselbe Loop, der Zug 37 fand — vorhersagen, Fehler messen, die Gewichte anstoßen, wiederholen — ist der Loop, der in jedem System dieser Liste läuft. Verstehe diesen Loop, und du verstehst Deep Learning; der Rest ist Architektur und Engineering darauf aufgesetzt.