Ein Netz, das seine Zahlen verändert

Im vierten Teil haben wir verfolgt, wie unser Netz ein Wort verarbeitet. Die Gewichte und Bias-Werte waren fest eingestellt. Jetzt lassen wir ein Programm diese Parameter anhand von Beispielen verändern.

Dazu brauchen wir mehr als den Vorwärtsdurchlauf: eine gewünschte Ausgabe, eine Fehlerfunktion und eine Methode, um den Einfluss der Parameter auf den Fehler zu bestimmen. Am Ende dieses Artikels trainieren wir unser 2–2–1-Netz tatsächlich. Die Berechnungen bleiben klein genug, um einzelne Schritte nachzurechnen.

Praxistest: Die Trainingsanleitung und ihre Ausgaben wurden in einer Linux-Mint-VM nachvollzogen und bestätigt.

↑ Nach oben

Was soll das Netz lernen?

Wir bleiben bei unserer künstlichen Aufgabe: Das Netz erhält zwei Merkmale eines Wortes. x1 ist 1 bei mindestens fünf Zeichen, x2 ist 1 bei einem großen K am Anfang. Das gewünschte Ergebnis ist 1, wenn beide Eigenschaften zutreffen, sonst 0.

Trainingswort Merkmale (x1, x2) Zielwert
Katze (1, 1) 1
Klee (0, 1) 0
Elefant (1, 0) 0
Maus (0, 0) 0

Wir beginnen mit den Parametern aus Teil 4: h1 und h2 haben je die Eingangsgewichte (1, 1) und die Bias-Werte -1 beziehungsweise 0. Das Ausgabeneuron verwendet die Gewichte (1, 0,5) und Bias 0. Alle drei Neuronen nutzen ReLU. Diese festen Startwerte machen unseren Versuch reproduzierbar. Es gibt hier keine Zufallsinitialisierung und deshalb keinen benötigten Zufalls-Seed.

Für „Katze“ berechnet das Netz zunächst h1 = 1, h2 = 2 und y = 2. Der gewünschte Zielwert ist aber 1. Wir brauchen eine Zahl, die diese Abweichung bewertet.

↑ Nach oben

Die Fehlerfunktion

Für ein einzelnes Beispiel verwenden wir den quadratischen Fehler:

Fehler L = (Vorhersage y - Zielwert t)²

Bei „Katze“ ist y = 2 und t = 1. Der Fehler ist (2 - 1)² = 1. Bei „Klee“ ist y = 0,5 und t = 0, also beträgt der Fehler 0,25. Eine Vorhersage von 0,5 ist in unserem Beispiel eine Zahl und keine Wahrscheinlichkeit.

Für den Trainingssatz bilden wir den Durchschnitt der vier Einzelfehler. Diesen Wert nennen wir mittleren quadratischen Fehler, kurz MSE. Ziel des Trainings ist es, diesen Durchschnitt durch passende Parameter zu verringern. Die Fehlerfunktion beschreibt, was wir verbessern möchten. Sie legt noch nicht fest, wie die Gewichte geändert werden.

Ein Trainingsschritt unseres Netzes

Die Gradienten werden für alle Trainingsbeispiele bei denselben Parametern berechnet und gemittelt.

  1. Vorwärtsdurchlauf

    Merkmale durch beide Schichten rechnen und Vorhersagen erzeugen

  2. Fehler

    Vorhersagen mit Zielwerten vergleichen und mittleren quadratischen Fehler bestimmen

  3. Backpropagation

    Mit der Kettenregel Gradienten vom Fehler bis zu Gewichten und Bias-Werten berechnen

  4. Gradientenabstieg

    Die Parameter mit den gemittelten Gradienten und einer Lernrate verändern

  5. Nächster Schritt

    Mit den angepassten Parametern erneut vorwärts rechnen

↑ Nach oben

Ein einzelnes Gewicht nachrechnen

Zunächst betrachten wir nur „Katze“ und nur das Ausgabegewicht v1 zwischen h1 und y. Es beginnt bei 1. Alle anderen Parameter bleiben für diese Rechnung fest. Für „Katze“ ist h1 = 1, h2 = 2 und der Zielwert t = 1:

z_y = v1 × h1 + 0,5 × h2 + 0 = 1 × 1 + 0,5 × 2 = 2
y = ReLU(z_y) = 2
L = (y - t)² = (2 - 1)² = 1

Wir fragen: Wie stark ändert sich der Fehler, wenn sich v1 ein kleines Stück ändert? Der Gradient ist hier diese Änderungsrate. Die Kettenregel verbindet die Teilschritte:

Änderung von L nach y:       2 × (y - t) = 2
Änderung von y nach z_y:     1, weil z_y > 0 und ReLU dort die Eingabe durchlässt
Änderung von z_y nach v1:    h1 = 1
Gradient für v1:             2 × 1 × 1 = 2

Der Gradient ist positiv. Eine kleine Verringerung von v1 senkt an dieser Stelle den Fehler. Bei einer Lernrate von 0,1 rechnet ein Gradientenabstieg:

neues v1 = altes v1 - Lernrate × Gradient
         = 1 - 0,1 × 2 = 0,8

Mit v1 = 0,8 ergibt sich für dasselbe Beispiel y = 0,8 × 1 + 0,5 × 2 = 1,8. Der neue Fehler ist (1,8 - 1)² = 0,64. Er ist für dieses eine Beispiel gesunken. Das beweist noch nicht, dass derselbe Schritt auch den mittleren Fehler aller Beispiele senkt. Unser späteres Programm mittelt deshalb die Gradienten über den gesamten Trainingssatz.

Was wird rückwärts gerechnet?

Beim Vorwärtslauf entstehen aus Eingaben über h1 und h2 die Vorhersage und der Fehler. Backpropagation nutzt diese gespeicherten Zwischenwerte und die Kettenregel, um vom Fehler aus Gradienten für die Parameter zu berechnen. Sie aktualisiert die Parameter nicht selbst. Den eigentlichen Schritt übernimmt anschließend der Gradientenabstieg.

Für die verborgene Schicht läuft der Einfluss über das Ausgabeneuron zurück. Zum Beispiel wird der Gradient für h1 mit dem aktuellen Gewicht v1 weitergegeben. Dabei verwenden wir für alle Gradienten eines Schritts dieselben alten Parameter. Erst wenn sie berechnet und über die Beispiele gemittelt sind, ändern wir die Parameter gemeinsam.

ReLU braucht eine Sonderregel: Für eine negative Zwischensumme ist ihre Ableitung 0, für eine positive 1. Genau bei 0 ist die Funktion nicht differenzierbar. Für dieses Lehrprogramm wählen wir dort 0. Das ist eine übliche Festlegung für die Berechnung. Sie hat eine praktische Folge: Ein Neuron kann auf bestimmten Beispielen einen Gradienten von 0 erhalten. Eine andere Initialisierung oder Lernrate kann deshalb ganz andere Ergebnisse liefern.

↑ Nach oben

Trainingsdaten und Prüfdaten trennen

Wir trainieren mit den vier Wörtern aus der Tabelle. Danach prüfen wir mit anderen Wörtern:

Prüfwort Merkmale Zielwert
Karte (1, 1) 1
Kuh (0, 1) 0
Apfel (1, 0) 0
Ei (0, 0) 0

Die Prüfwörter werden nicht für Parameterupdates verwendet. Allerdings enthalten sie dieselben vier Merkmalskombinationen wie die Trainingsdaten. Unser Netz kann Wörter mit gleichen Merkmalen nicht unterscheiden. Gute Prüfergebnisse hier zeigen also nur, dass die Datenaufteilung und Berechnung funktionieren. Sie sind kein aussagekräftiger Nachweis für Generalisierung auf neue Merkmale oder echtes Sprachverständnis.

↑ Nach oben

Ein trainierbares Netz in Python

Wir verwenden neuron.py aus Teil 3 und lassen netz.py aus Teil 4 unverändert. Die neue Datei trainieren.py nutzt dieselbe Neuronenfunktion und dieselbe Netzarchitektur. Sie speichert nach dem Training die neun Parameter in einer JSON-Datei. Die Trainingsdaten und die Prüfdaten sind bewusst kleine, fest vorgegebene Listen.

Öffne ein Terminal in der Linux-VM und wechsle in den Projektordner:

cd ~/eigene-ki

Aktiviere bei Bedarf die Umgebung mit source .venv/bin/activate. Für diesen Teil brauchen wir keine zusätzlichen Pakete. Erstelle trainieren.py mit folgendem Inhalt:

import json
import sys

from neuron import neuron


TRAINING = [("Katze", 1), ("Klee", 0), ("Elefant", 0), ("Maus", 0)]
PRUEFUNG = [("Karte", 1), ("Kuh", 0), ("Apfel", 0), ("Ei", 0)]
LERNRATE = 0.1
SCHRITTE = 1000


def merkmale(wort):
    return (int(len(wort) >= 5), int(wort.startswith("K")))


def startparameter():
    return {"w": [[1.0, 1.0], [1.0, 1.0]], "b": [-1.0, 0.0],
            "v": [1.0, 0.5], "c": 0.0}


def vorwaerts(x, p):
    _, z1, h1 = neuron(x, p["w"][0], p["b"][0])
    _, z2, h2 = neuron(x, p["w"][1], p["b"][1])
    _, zy, y = neuron((h1, h2), p["v"], p["c"])
    return (z1, z2), (h1, h2), zy, y


def fehler(y, ziel):
    return (y - ziel) ** 2


def mittelwert_fehler(daten, p):
    return sum(fehler(vorwaerts(merkmale(wort), p)[3], ziel)
               for wort, ziel in daten) / len(daten)


def gradienten(x, ziel, p):
    z, h, zy, y = vorwaerts(x, p)
    # Für ReLU setzen wir die Ableitung bei z == 0 auf 0.
    delta_y = 2 * (y - ziel) * (1.0 if zy > 0 else 0.0)
    delta_h = [delta_y * p["v"][i] * (1.0 if z[i] > 0 else 0.0)
               for i in range(2)]
    return {
        "w": [[delta_h[i] * x[j] for j in range(2)] for i in range(2)],
        "b": delta_h,
        "v": [delta_y * h[i] for i in range(2)],
        "c": delta_y,
    }


def trainingsschritt(daten, p, lernrate):
    # Erst alle Gradienten mit denselben alten Parametern berechnen.
    gs = [gradienten(merkmale(wort), ziel, p) for wort, ziel in daten]
    n = len(gs)
    for i in range(2):
        for j in range(2):
            p["w"][i][j] -= lernrate * sum(g["w"][i][j] for g in gs) / n
        p["b"][i] -= lernrate * sum(g["b"][i] for g in gs) / n
        p["v"][i] -= lernrate * sum(g["v"][i] for g in gs) / n
    p["c"] -= lernrate * sum(g["c"] for g in gs) / n


def gradient_pruefen():
    p = startparameter()
    x = merkmale("Katze")
    analytisch = gradienten(x, 1, p)["v"][0]
    epsilon = 0.00001
    p["v"][0] += epsilon
    plus = fehler(vorwaerts(x, p)[3], 1)
    p["v"][0] -= 2 * epsilon
    minus = fehler(vorwaerts(x, p)[3], 1)
    numerisch = (plus - minus) / (2 * epsilon)
    print(f"Gradient v1: analytisch={analytisch:.6f}, numerisch={numerisch:.6f}")


def main():
    if len(sys.argv) > 1:
        if len(sys.argv) != 3 or sys.argv[1] != "--vorhersage":
            raise SystemExit("Verwendung: python trainieren.py [--vorhersage WORT]")
        try:
            with open("parameter.json", encoding="utf-8") as datei:
                p = json.load(datei)
        except FileNotFoundError:
            raise SystemExit("parameter.json fehlt. Zuerst python trainieren.py ausführen.")
        wort = sys.argv[2]
        y = vorwaerts(merkmale(wort), p)[3]
        print(f"{wort}: Ausgabe={y:.4f}, Klasse={'ja' if y >= 0.5 else 'nein'}")
        return

    gradient_pruefen()
    p = startparameter()
    print(f"Trainingsfehler vor dem Training: {mittelwert_fehler(TRAINING, p):.6f}")
    for _ in range(SCHRITTE):
        trainingsschritt(TRAINING, p, LERNRATE)
    print(f"Trainingsfehler nach {SCHRITTE} Schritten: {mittelwert_fehler(TRAINING, p):.6f}")
    print(f"Prüffehler: {mittelwert_fehler(PRUEFUNG, p):.6f}")
    for wort, ziel in PRUEFUNG:
        y = vorwaerts(merkmale(wort), p)[3]
        print(f"{wort}: Ziel={ziel}, Ausgabe={y:.4f}")
    with open("parameter.json", "w", encoding="utf-8") as datei:
        json.dump(p, datei, indent=2)
    print("Parameter gespeichert: parameter.json")


if __name__ == "__main__":
    main()

Der Aufruf gradient_pruefen() vergleicht den analytischen Gradienten für v1 mit einer zentralen numerischen Differenz: Er berechnet den Fehler einmal mit etwas größerem und einmal mit etwas kleinerem Gewicht. Die Differenz der Fehler geteilt durch den Abstand der beiden Gewichte nähert die Steigung an. Wir prüfen damit einen einzelnen Gradienten an einem Punkt, nicht automatisch die gesamte Implementierung.

Bei jedem Trainingsschritt berechnet gradienten() die Ableitungen für ein Beispiel. trainingsschritt() sammelt sie für alle vier Trainingswörter und bildet ihren Durchschnitt. Erst danach verändert die Funktion alle sechs Gewichte und drei Bias-Werte. Die Prüfliste fließt nicht in diese Aktualisierung ein.

Starte den Versuch:

python trainieren.py

Das Programm zeigt den analytischen und den numerischen Gradienten, den Trainingsfehler vor und nach dem Training, den Prüffehler und die Vorhersagen für die Prüfwörter. Bei einem lokalen Lauf mit den angegebenen Werten entstand folgende Ausgabe:

Gradient v1: analytisch=2.000000, numerisch=2.000000
Trainingsfehler vor dem Training: 0.375000
Trainingsfehler nach 1000 Schritten: 0.000000
Prüffehler: 0.000000
Karte: Ziel=1, Ausgabe=1.0000
Kuh: Ziel=0, Ausgabe=0.0000
Apfel: Ziel=0, Ausgabe=0.0000
Ei: Ziel=0, Ausgabe=0.0000
Parameter gespeichert: parameter.json

Die Ausgabe ist gerundet. 0.000000 bedeutet deshalb nicht zwingend, dass der Fehler mathematisch exakt null ist.

Am Ende schreibt das Programm parameter.json im Projektordner. Eine vorhandene Datei mit diesem Namen wird überschrieben. Die Datei enthält die trainierten Parameter. Unser bisheriges netz.py verwendet weiterhin seine fest einprogrammierten Parameter und lädt diese Datei nicht automatisch.

Mit dem folgenden Befehl lädt trainieren.py die gespeicherten Parameter für eine neue Vorhersage, ohne das Netz erneut zu trainieren:

python trainieren.py --vorhersage Karte

Erwartet wird eine Ausgabe nahe 1.0000 und die Klasse ja. Für diese trainierten Zielwerte verwenden wir bei der Klassifizierung hier die zusätzliche Grenze 0,5: Werte ab 0,5 ergeben ja, kleinere nein. Das ist eine Entscheidung unseres Programms nach dem Netz, kein vom Netz gelerntes Gewicht. In Teil 4 hatten wir für die damaligen handgewählten Parameter eine Grenze von 1 verwendet. Die Ausgabe selbst ist weiterhin keine Wahrscheinlichkeit.

↑ Nach oben

Selbst überprüfen

  1. Vergleiche den angezeigten Gradienten für v1 mit der Handrechnung. Warum ist die numerische Prüfung nur eine Näherung?
  2. Starte python trainieren.py erneut. Weil Daten und Startparameter fest vorgegeben sind, sollten die Ergebnisse bei gleicher Python-Umgebung gleich sein. Die vorhandene parameter.json wird dabei neu geschrieben.
  3. Verändere testweise SCHRITTE auf 1 und vergleiche den Trainingsfehler nach einem Schritt mit dem Ergebnis nach 1000 Schritten. Setze den Wert danach zurück.
  4. Ändere testweise die Lernrate. Ein größerer Wert garantiert keinen schnelleren Erfolg und kann das Training instabil machen. Stelle anschließend 0.1 wieder her.

Bei ModuleNotFoundError prüfe, ob neuron.py aus Teil 3 im selben Ordner liegt und das Terminal in ~/eigene-ki steht. Bei unerwarteten Ergebnissen kontrolliere zuerst die Startparameter, LERNRATE und SCHRITTE. In der Dokumentation zum tiefen Lernen werden Vorwärtslauf, Kettenregel und Backpropagation ausführlich hergeleitet.

↑ Nach oben

Wie geht es weiter?

Unser Netz kann nun seine Parameter anhand von Beispielen verändern. Die Daten und die Aufgabe bleiben bewusst winzig. Im nächsten Teil untersuchen wir, was mehrere Schichten und nichtlineare Funktionen leisten können und wo ein einfaches lineares Modell an Grenzen stößt.

↑ Nach oben