Künstliches neuronales Netz

Ein Rechenmodell nach dem Vorbild des Gehirns: Schichten von Knoten, die gewichtete Signale summieren und über eine Aktivierungsfunktion weitergeben. Es lernt aus Beispielen, indem es seine Gewichte mit Backpropagation und Gradientenverfahren anpasst. So löst es Aufgaben wie Bilderkennung, für die sich keine Regeln aufschreiben lassen.

Vorbild und Grundidee

Für Computer leicht und für Menschen schwer ist das Rechnen mit Millionen Zahlen. Umgekehrt ist das Erkennen von Gesichtern für Menschen leicht und für herkömmliche Programme schwer (Quelle - Neuronale Netze selbst programmieren, S. 15–16). Biologische Gehirne sind langsam, arbeiten aber parallel und unscharf und sind robust gegen Schäden: Ein Fadenwurm kommt mit 302 Neuronen aus, eine Fruchtfliege mit rund 100 000, der Mensch hat etwa 100 Milliarden (S. 44–45).

Ein biologisches Neuron sammelt über die Dendriten Signale und feuert erst über einer Schwelle über das Axon an nachfolgende Neuronen. Das künstliche Modell:

• ein Knoten summiert seine Eingänge und wendet eine Aktivierungsfunktion an
• Knoten sind in Schichten angeordnet: Eingabeschicht (gibt nur die Eingaben weiter), eine oder mehrere versteckte Schichten, Ausgabeschicht
• meist ist jeder Knoten mit jedem der nächsten Schicht verbunden (vollständig verbunden)
• jede Verbindung hat ein Gewicht, das Signale verstärkt oder abschwächt. Gelernt werden die Gewichte. Unnötige Verbindungen erhalten beim Lernen Gewichte nahe null (S. 49–52).

Warum mehrere Knoten? Ein einzelner Linearer Klassifikator scheitert schon an XOR, mehrere zusammen nicht (S. 38–43; ausführlich in Perzeptron).

Das biologische Vorbild genauer

Quelle - Neuronale Netze programmieren mit Python (Kap. 1 und 9) beschreibt die Biologie ausführlicher:

• Signale kommen über die Dendriten und Synapsen an. Synapsen wandeln das elektrische Signal in ein chemisches (Neurotransmitter im etwa 40 nm breiten synaptischen Spalt) und wirken erregend oder hemmend. Das bilden die positiven und negativen Gewichte nach (S. 33–35, 274–276).
• Am Axonhügel entscheidet sich nach dem Alles-oder-nichts-Gesetz, ob ein Aktionspotenzial (etwa 0,1 Volt, 1–2 ms) ausgelöst wird. Das bildet die Schwelle bzw. Aktivierungsfunktion nach (S. 34, 278).
• Die Stärke eines Reizes codiert das Neuron nicht über die Amplitude, sondern über die Frequenz der Aktionspotenziale (z.B. 50 statt 170 pro Sekunde). Das greifen Spiking Neural Networks auf (S. 269, 278).
• Die Hirnrinde ist 0,25 m² gross, etwa 4 mm dick und in sechs Schichten gegliedert. Jedes Neuron hat im Mittel rund 1000 Synapsen, das ergibt etwa 100 Billionen Verbindungen (S. 271–274).

Ein minimales Beispiel: die Bienenkönigin

Das zweite Buch beginnt mit einem Netz aus einem Eingang und einem Ausgang: Eine Biene ist die Königin, wenn sie mindestens 20 mm lang ist (Königinnen 20–25 mm, Drohnen 15–17 mm, Arbeiterinnen 12–14 mm). Gewicht 1, Schwelle (Bias) 20, Stufenfunktion: Eine 21-mm-Biene ergibt 21 − 20 = 1 ≥ 0, also Ausgabe 1 („Königin“), eine 14-mm-Biene ergibt 0 (Quelle - Neuronale Netze programmieren mit Python, S. 25–31). Dasselbe liesse sich mit einer Wenn-dann-Regel lösen. Das Netz zeigt aber alle Grundbausteine grosser Netze.

Netze, die Signale nur vorwärts weitergeben, heissen Feed-forward-Netze. Netze mit Rückkopplung heissen rekurrent (S. 31), etwa das Hopfield-Netz und LSTM (siehe Geschichte der neuronalen Netze).

Signalfluss (Feedforward)

Der Eingang eines Knotens ist die gewichtete Summe der Ausgänge der Vorgängerschicht. Beispiel (S. 56–57): Eingänge 1,0 und 0,5, Gewichte 0,9 und 0,3 ergeben x = 1,05, sigmoid(1,05) = 0,7408. Der zweite Knoten ergibt 0,6457. Nachgerechnet, stimmt.

Mit Matrizen wird das für beliebig grosse Netze kurz (S. 58–72):

X = W · I und O = sigmoid(X)

W ist die Gewichtsmatrix zwischen zwei Schichten, I der Vektor der Eingänge. Dasselbe wiederholt sich für jede weitere Schicht. Programmiersprachen mit Matrixunterstützung wie Python mit numpy rechnen das sehr effizient. Das Buch rechnet ein Netz mit drei Schichten zu je drei Knoten durch (Ausgaben 0,726, 0,708 und 0,778).

Lernen

1. Eingabe vorwärts durchleiten
2. Fehler an der Ausgabe berechnen (Soll − Ist)
3. Fehler rückwärts verteilen (Backpropagation)
4. Gewichte in kleinen Schritten gegen die Fehlersteigung anpassen (Gradientenverfahren)

Daten vorbereiten

Viele Misserfolge lassen sich laut Buch vermeiden (S. 103–108):

• Eingaben auf kleine Werte skalieren, aber nicht null, z.B. 0,01 bis 1,0. Nulleingänge blockieren das Lernen.
• Zielwerte im erreichbaren Bereich der Aktivierungsfunktion, bei Sigmoid 0,01 bis 0,99, sonst wachsen die Gewichte ins Unendliche und das Netz sättigt.
• Anfangsgewichte klein und zufällig, z.B. normalverteilt mit Streuung 1/√(Anzahl eingehender Verbindungen). Nie alle gleich oder null: Sonst lernen alle Knoten dasselbe (Symmetrie) oder gar nichts.

Das Netz in Python

Das Buch baut eine Klasse neuralNetwork mit drei Methoden (S. 132–147):

• __init__: Knotenzahlen, Lernrate, zufällige Gewichtsmatrizen wih und who, Aktivierungsfunktion
• query: Eingaben vorwärts durchleiten, vier Zeilen Matrixrechnung
• train: wie query, dazu Fehler berechnen, zurückführen und beide Gewichtsmatrizen anpassen

Für die Ziffernerkennung mit MNIST hat es 784 Eingänge (28 × 28 Pixel), 10 Ausgänge (eine pro Ziffer, das stärkste Signal gilt als Antwort) und zunächst 100, später 200 versteckte Knoten.

Was die Leistung bestimmt

• Anzahl versteckter Knoten: Zu wenige begrenzen die Lernkapazität, zu viele machen das Training langsam und schwierig. Eine Regel gibt es nicht, man muss probieren.
• Epochen: Zu viele führen zu Überanpassung (Overfitting): Das Netz lernt die Trainingsdaten auswendig und wird bei neuen Daten schlechter.
• Zusätzliche Trainingsdaten aus vorhandenen erzeugen (hier durch Drehen): billig und wirksam. Zu grosse Drehwinkel schaden, eine liegende „3“ ist keine „3“ mehr.
• Das Netz erkennt auch eigene Handschrift und beschädigte Ziffern, versagt aber bei stark verrauschten Bildern (S. 177–180).

Tiefe Netze

Deep Neural Networks haben viele versteckte Schichten und können dadurch sehr komplexe Zusammenhänge lernen. Warum nicht schon früher? „Uns fehlten die Rechenleistung und die Daten“ (Quelle - Neuronale Netze programmieren mit Python, S. 42–44). Grafikprozessoren (GPU) mit Tausenden Rechenkernen und Googles TPU machten sie ab etwa 2011 praktikabel. Die zwei wichtigsten Architekturen sind das Faltungsnetz für Bilder und der Transformer für Sprache. Mit Frameworks wie TensorFlow oder PyTorch genügen wenige Zeilen, um sie zu bauen. Tiefe Netze bringen eigene Probleme mit: verschwindende Gradienten (siehe Aktivierungsfunktion) und Überanpassung.

Blackbox und Rückwärtsabfrage

Ein trainiertes Netz ist eine Blackbox: Man sieht nicht, warum es eine Antwort gibt, das Wissen ist über viele Gewichte verteilt. Das Buch schickt deshalb eine Kennung rückwärts durch das Netz, mit der Logit-Funktion als Umkehrung der Sigmoidfunktion. Heraus kommt ein Bild dessen, was das Netz für eine „0“ hält: dunkle Bereiche, die gezeichnet sein müssen, helle, die frei bleiben müssen (S. 180–184).

Verwandt

• Linearer Klassifikator – der einzelne Baustein und seine Grenze
• Perzeptron – das historische Grundmodell, Adaline und XOR
• Faltungsnetz – tiefe Netze für Bilder
• Transformer – tiefe Netze für Sprache
• Überanpassung – wenn das Netz auswendig lernt
• Maschinelles Lernen – das übergeordnete Fachgebiet
• Geschichte der neuronalen Netze – von McCulloch-Pitts bis zum Transformer
• KI-Ethik – Erklärbarkeit der Blackbox
• Aktivierungsfunktion – Sigmoid, ReLU, Leaky ReLU
• Backpropagation – wie der Fehler zurückgeführt wird
• Gradientenverfahren – wie die Gewichte angepasst werden
• MNIST – der Datensatz der Beispiele
• PyTorch – dasselbe Netz mit einem Framework
• Mustererkennung – neuronale Netze als Klassifikator in der Bildverarbeitung
• Merkmalsextraktion – tiefe Netze lernen Merkmale selbst
• Wissensrepräsentation damals und heute – symbolisches gegen konnektionistisches Wissen
• Claude – ein grosses neuronales Netz