7.1 Neuronale Netze: Perzeptron & MLP

Kapitel 7 · Neuronale KI & Deep Learning

Noah Kolb · Sommersemester 2026

‹ Alle ThemenVertiefung

Worum geht’s

Die Verfahren der vorangegangenen Kapitel — Suche, CSP, Entscheidungsbäume — verarbeiten Symbole nach von Hand notierten Regeln. Neuronale Netze gehen den umgekehrten Weg: Sie bestehen aus sehr vielen, sehr einfachen Recheneinheiten und lernen ihr Verhalten aus Daten, statt es vorgeschrieben zu bekommen. Das Vorbild ist grob die Nervenzelle: viele Eingänge, ein gewichtetes Aufsummieren, ein „Feuern”, wenn die Summe einen Schwellwert übersteigt.

Mich hat an diesem Kapitel gereizt, dass die kleinste Einheit — das Perzeptron von Rosenblatt (1958) — sich auf einer Postkarte notieren lässt und trotzdem den Kern dessen enthält, was moderne Netze tun: eine gewichtete Summe, eine nichtlineare Schwelle, eine Lernregel, die Gewichte anhand von Fehlern anpasst. Wer das Perzeptron verstanden hat, versteht das Bauteil, aus dem ein Deep-Learning-Modell millionenfach zusammengesetzt ist.

Kernkonzepte

Das künstliche Neuron

Ein Perzeptron bildet einen Eingabevektor x=(x1,…,xn)x = (x_1, \dots, x_n) über Gewichte wiw_i und einen Bias bb auf eine Ausgabe ab. Es bildet die gewichtete Summe z=∑iwixi+bz = \sum_i w_i x_i + b und gibt deren Vorzeichen zurück.

Genau diese Geometrie macht die folgende Insel sichtbar. Die Punkte sind zwei Klassen, die Gerade ist das Perzeptron; der kleine Pfeil ist der Gewichtsvektor ww. Über die Schieberegler lässt sich die Gerade von Hand legen — oder das Perzeptron lernt sie selbst, Schritt für Schritt, aus seinen Fehlern.

Perzeptron-Spielwieseinteraktiv
Klick setzt:
0.90·x + -0.20·y + 0.00 = 0falsch: 0/18 · Genauigkeit 100 %
Klasse +1Klasse −1schwarz umrandet = falsch klassifiziert

Tipp: Setze die Punkte so, dass keine Gerade sie mehr trennt — das Training konvergiert dann nicht mehr (Perzeptron-Konvergenztheorem).

Falsch klassifizierte Punkte sind schwarz umrandet. „Trainieren” wendet die Lernregel wiederholt an; setzt man die Punkte so, dass keine Gerade sie mehr trennt, konvergiert das Training nicht mehr.

Die Lernregel

Lernen heißt hier: Anpassen der Gewichte (die „Stellschrauben”), während Schwellwert, Aktivierungs- und Ausgabefunktion in der Regel fest bleiben. Die Foliensätze führen dazu die Delta-Regel (Widrow-Hoff-Regel) ein. Sie ändert jedes Gewicht proportional zum Fehler δ=(teach_output−actual_output)\delta = (\text{teach\_output} - \text{actual\_output}) und zur jeweiligen Eingabe oio_i:

wi←wi+η (teach_output−actual_output) oi,w_i \leftarrow w_i + \eta\,(\text{teach\_output} - \text{actual\_output})\,o_i,

mit der Lernrate 0<η≤10 < \eta \le 1. Die Multiplikation mit oio_i bewirkt, dass nur diejenigen Gewichte verändert werden, die zum Netzfehler beigetragen haben; die Konvergenz nach endlich vielen Schritten folgt beim Perzeptron aber aus der linearen Trennbarkeit der Daten, nicht allein aus der Schranke für η\eta. In der Spielwiese sind die Klassen mit t∈{+1,−1}t \in \{+1,-1\} codiert — anschaulich kippt jeder Fehler die Trennebene so, dass der Punkt das nächste Mal etwas „richtiger” liegt.

Die Grenze: XOR und der Weg zum MLP

Die Kehrseite der Einfachheit: Ein Perzeptron kann nur linear trennbare Probleme lösen — AND und OR ja, XOR nicht. Vier Punkte, deren Klassen über Kreuz liegen; keine einzige Gerade trennt sie. Die Folien zeigen das auch rechnerisch: Soll ein Neuron XOR realisieren, müsste gelten 0⋅w1+1⋅w2≥θ0\cdot w_1 + 1\cdot w_2 \ge \theta und 1⋅w1+0⋅w2≥θ1\cdot w_1 + 0\cdot w_2 \ge \theta; addiert man beide Ungleichungen, folgt w1+w2≥2θw_1 + w_2 \ge 2\theta, im Widerspruch zur Forderung 1⋅w1+1⋅w2<θ1\cdot w_1 + 1\cdot w_2 < \theta für das vierte Muster. Es gibt also keine passenden Gewichte. Diese Erkenntnis (kritisch diskutiert von Minsky & Papert, Perceptrons, 1969) führte in den 1970er Jahren zu einem „NN-Winter”. Die Lösung ist, Perzeptronen zu schichten: Ein Multi-Layer-Perzeptron (MLP) mit einer verdeckten Schicht und einer nichtlinearen Aktivierung (Sigmoid, ReLU) kann beliebige stetige Funktionen approximieren (universeller Approximationssatz). Trainiert wird es mit Backpropagation — der Verallgemeinerung der Delta-Regel auf mehrere trainierbare Schichten. Im Kern ist es die Kettenregel, die den Fehler von der Ausgabe rückwärts durch die Schichten leitet und so für jedes Gewicht den Gradienten bestimmt.

Praxis

Um das Konvergenztheorem nicht nur zu glauben, habe ich das Perzeptron in reinem NumPy nachgebaut und auf zwei Datensätze losgelassen: eine linear trennbare Punktwolke und XOR. Der Kern ist die Lernregel von oben — bei der ±1-Codierung fällt der Fehlerterm (teach−actual)(\text{teach} - \text{actual}) mit dem Vorzeichen tt zusammen, sodass nur bei einer Fehlklassifikation w+=η t xw \mathrel{+}= \eta\,t\,x korrigiert wird:

def _train_perceptron(X, y, epochs, lr, seed):
    rng = np.random.default_rng(seed)
    w = rng.normal(scale=0.1, size=X.shape[1])
    b = 0.0
    errors = []
    for _ in range(epochs):
        err = 0
        for xi, target in zip(X, y):
            pred = 1 if np.dot(w, xi) + b > 0 else -1
            if pred != target:               # nur Fehler korrigieren Gewichte
                w = w + lr * target * xi
                b = b + lr * target
                err += 1
        errors.append(err)
    return w, b, errors

Das vollständige Skript (Datensätze, Plots) liegt in python/src/eport_figures/praxis/p_7_1_neuronale_netze.py und wird über generate ausgeführt. Seine Ausgabe:

Trennbare Menge: 60 Punkte, 2 Klassen
  Gewichte  w = [+0.155, +0.053],  Bias b = +0.000
  Fehler je Epoche: [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  Endgenauigkeit: 100.0 %
  -> 0 Fehler ab Epoche 2 (Perzeptron-Konvergenztheorem).

XOR-Problem (nicht linear trennbar):
  Fehler je Epoche (Auszug): [2, 2, 3, 4, 4, 4] … [4, 4, 4]
  min. Fehler = 2 von 4 — keine Gerade trennt XOR. Lösung: verdeckte Schicht (MLP).
Punktwolke zweier Klassen mit gelernter Trenngerade

Die nach dem Training gefundene Trennebene auf der linear trennbaren Menge.

Fehlklassifikationen je Epoche, fällt nach Epoche 2 auf null

Die Lernkurve fällt nach der zweiten Epoche auf null — genau die endliche Fehlerzahl, die das Konvergenztheorem verspricht. Bei XOR fällt die entsprechende Kurve nie auf null.

Der direkte Vergleich beider Läufe macht den theoretischen Satz greifbar: Im trennbaren Fall hört das Lernen auf (0 Fehler ab Epoche 2), bei XOR pendelt es dauerhaft bei mindestens zwei Fehlern. Damit ist die Brücke zum nächsten Thema geschlagen — erst die verdeckte Schicht des MLP überwindet diese Grenze.

Querbezüge

  • 3.1 / 3.2 (Maschinelles Lernen): Das Perzeptron ist ein linearer Klassifikator. Die Lernregel ist ein Spezialfall des Gradientenabstiegs, der dort allgemein eingeführt wird; die Support Vector Machine (3.2) sucht dieselbe trennende Ebene, optimiert aber zusätzlich den Abstand (Margin) statt nur „irgendeine” Trennung.
  • 7.2 (CNN): Ein Convolutional Net ist im Kern ein MLP mit geteilten Gewichten und lokaler Verschaltung — dieselbe Neuron-Idee, nur strukturiert für Bilder.
  • 6.1 (Reinforcement Learning): Wird die Q-Funktion zu groß für eine Tabelle, approximiert man sie durch ein neuronales Netz (Deep Q-Learning).
  • Andere Module: Die gewichtete Summe w⋅xw\cdot x ist ein Skalarprodukt (Lineare Algebra), die Lernregel ein Gradientenschritt (Analysis/Numerik), und Backpropagation ist nichts als die Kettenregel, effizient organisiert.

Quellen