Ein Neuron aus unserem Netz herausgreifen
Im zweiten Teil haben wir ein kleines Netz gebaut. Es bekommt zwei Merkmale eines Wortes und berechnet daraus über h1 und h2 einen Ausgabewert. Die Gewichte haben wir selbst festgelegt. Gelernt hat das Netz noch nicht.
Jetzt schauen wir uns ein einzelnes künstliches Neuron genauer an. Wir verfolgen jede Zahl durch h1, rechnen Beispiele von Hand und schreiben eine Funktion, die wir anschließend in unserem Netz wiederverwenden. Das ist ein technisches Rechenmodell, keine Simulation einer biologischen Nervenzelle.
Praxistest: Der Ablauf und die Codeänderungen wurden in einer Linux-Mint-VM nachvollzogen und bestätigt.
Ausgangspunkt: „Katze“
Wir verwenden dieselben Merkmale wie bisher: x1 ist 1, wenn das Wort mindestens fünf Zeichen hat. x2 ist 1, wenn es mit einem großen K beginnt. Für „Katze“ gilt beides, also ist unsere Eingabe (1, 1).
Im vorherigen Teil hat h1 diese festen Parameter bekommen:
| Bedeutung | Wert |
|---|---|
Eingabe x1 |
1 |
Eingabe x2 |
1 |
Gewicht für x1 |
1 |
Gewicht für x2 |
1 |
| Bias | -1 |
Gewichte und Bias gehören zum Neuron. Die Eingaben hängen vom jeweiligen Wort ab. Für diese Werte sieht der Weg durch h1 so aus:
Die Schritte zeigen die konkreten Werte für x1 = 1 und x2 = 1.
- Eingaben
x1 = 1 und x2 = 1
- Gewichten
1 × 1 = 1 und 1 × 1 = 1
- Addieren und Bias einbeziehen
1 + 1 - 1 = 1
- ReLU anwenden
max(0, 1) = 1
- Ausgabe von h1
Der Wert 1 geht an das nächste Neuron weiter.
Dieses Ablaufdiagramm zeigt die Rechnung eines Neurons. Das Netzdiagramm aus Teil 2 zeigt dagegen die Verbindungen zwischen mehreren Neuronen.
Schritt 1: Eingaben gewichten
Ein Gewicht ist eine Zahl, mit der eine Eingabe multipliziert wird. Dabei hat jede Verbindung ihr eigenes Gewicht. Schreiben wir w1 und w2 für die beiden Gewichte, dann entstehen zuerst die Beiträge x1 × w1 und x2 × w2.
Für „Katze“ und unsere Parameter erhalten wir:
x1 × w1 = 1 × 1 = 1
x2 × w2 = 1 × 1 = 1
x1 × w1 = 1 × 1 = 1
x2 × w2 = 1 × 1 = 1
Ein größeres positives Gewicht verstärkt den Beitrag für denselben Eingabewert. Ein negatives Gewicht kann ihn ins Negative drehen. Bei Gewicht 0 trägt diese Verbindung zur gewichteten Summe nichts bei. Ein negatives Gewicht macht die spätere Ausgabe nicht automatisch negativ, denn danach kommen noch Bias und Aktivierungsfunktion.
Das können wir an einer anderen Rechnung sehen: Für x1 = 1, x2 = 1, w1 = -2 und w2 = 1 sind die Beiträge -2 und 1. Das sind Beispielwerte, noch keine Änderung an unserem Netz.
Schritt 2: Beiträge addieren und Bias ergänzen
Das Neuron addiert die gewichteten Beiträge und seinen Bias. Diese Zwischensumme nennen wir z:
z = x1 × w1 + x2 × w2 + bias
z = x1 × w1 + x2 × w2 + bias
Für h1 und „Katze“ folgt z = 1 + 1 - 1 = 1. Der Bias ist ein weiterer Parameter des Neurons. Er wird addiert, auch wenn die Eingaben null sind. Verändern wir ihn bei sonst gleichen Werten von -1 auf -2, ergibt sich z = 1 + 1 - 2 = 0.
Der Bias beeinflusst damit, bei welchen Eingaben die nachfolgende Aktivierungsfunktion welche Werte liefert. Er ist nicht dasselbe wie die spätere Klassengrenze y >= 1 aus Teil 2. Diese Grenze wird erst nach der Ausgabe des gesamten Netzes angewendet.
Schritt 3: ReLU anwenden
Wir verwenden wie zuvor die Aktivierungsfunktion ReLU. Sie gibt für negative Zahlen 0 zurück und lässt nichtnegative Zahlen unverändert:
Eingabe z |
ReLU(z) = max(0, z) |
|---|---|
| -2 | 0 |
| 0 | 0 |
| 1 | 1 |
| 2 | 2 |
Für unser h1 ist z = 1, also ReLU(1) = 1. Für „Klee“ sind die Merkmale (0, 1). Dann ist z = 0 × 1 + 1 × 1 - 1 = 0, und die Ausgabe ist 0.
ReLU ist eine nichtlineare Funktion: Sie verhält sich für negative und positive Eingaben unterschiedlich. Ohne Nichtlinearität lassen sich rein lineare beziehungsweise affine Schichten zu einer einzigen affinen Rechnung zusammenfassen. Warum das für die Ausdrucksmöglichkeiten eines Netzes eine Rolle spielt, untersuchen wir in Teil 6. ReLU ist nur eine von mehreren möglichen Aktivierungsfunktionen. Sie liefert auch nicht automatisch Wahrscheinlichkeiten. Der Machine Learning Crash Course erklärt weitere Aktivierungsfunktionen.
Eine wiederverwendbare Funktion bauen
Öffne in deiner Linux-VM ein Terminal und gehe in den Projektordner aus Teil 1:
cd ~/eigene-ki
cd ~/eigene-ki
Falls du die automatische Aktivierung eingerichtet hast, wird die Umgebung beim Betreten geladen. Andernfalls aktiviere sie mit source .venv/bin/activate. Für dieses Beispiel brauchen wir keine zusätzlichen Pakete. Die Datei netz.py aus Teil 2 bleibt zunächst erhalten.
Erstelle im Projektordner eine Datei neuron.py mit diesem Inhalt:
def neuron(eingaben, gewichte, bias):
if len(eingaben) != len(gewichte):
raise ValueError("Für jede Eingabe wird ein Gewicht benötigt")
beitraege = [x * gewicht for x, gewicht in zip(eingaben, gewichte)]
z = sum(beitraege) + bias
ausgabe = max(0.0, z)
return beitraege, z, ausgabe
if __name__ == "__main__":
beitraege, z, ausgabe = neuron((1, 1), (1, 1), -1)
print(f"Beiträge: {beitraege}")
print(f"Summe mit Bias: {z}")
print(f"Ausgabe nach ReLU: {ausgabe}")
def neuron(eingaben, gewichte, bias):
if len(eingaben) != len(gewichte):
raise ValueError("Für jede Eingabe wird ein Gewicht benötigt")
beitraege = [x * gewicht for x, gewicht in zip(eingaben, gewichte)]
z = sum(beitraege) + bias
ausgabe = max(0.0, z)
return beitraege, z, ausgabe
if __name__ == "__main__":
beitraege, z, ausgabe = neuron((1, 1), (1, 1), -1)
print(f"Beiträge: {beitraege}")
print(f"Summe mit Bias: {z}")
print(f"Ausgabe nach ReLU: {ausgabe}")
Die Funktion gibt drei Dinge zurück: die einzelnen Produkte, die Summe einschließlich Bias und die Ausgabe nach ReLU. zip verbindet jeweils eine Eingabe mit dem zugehörigen Gewicht. Die Prüfung davor verhindert, dass bei unterschiedlich langen Folgen Werte unbemerkt wegfallen. Der Block unter if __name__ == "__main__": läuft nur, wenn wir neuron.py direkt starten, nicht beim Import in unser Netz.
Führe die Datei aus:
python neuron.py
python neuron.py
Die erwartete Ausgabe passt zu unserer Handrechnung:
Beiträge: [1, 1]
Summe mit Bias: 1
Ausgabe nach ReLU: 1
Beiträge: [1, 1]
Summe mit Bias: 1
Ausgabe nach ReLU: 1
Python kann bei anderen Eingaben auch Dezimalzahlen wie 1.0 ausgeben. An der Bedeutung ändert das nichts.
Das Neuron im bestehenden Netz verwenden
Als Nächstes ersetzen wir die bisher dreimal ausgeschriebene Neuronenrechnung in netz.py durch Aufrufe unserer neuen Funktion. Die Merkmale, Gewichte, Bias-Werte und die Klassengrenze bleiben gleich. Öffne netz.py und ersetze den gesamten Inhalt durch:
from neuron import neuron
def vorhersage(text):
x1 = int(len(text) >= 5)
x2 = int(text.startswith("K"))
gewichte_verborgen = ((1.0, 1.0), (1.0, 1.0))
bias_verborgen = (-1.0, 0.0)
gewichte_ausgabe = (1.0, 0.5)
bias_ausgabe = 0.0
_, _, h1 = neuron((x1, x2), gewichte_verborgen[0], bias_verborgen[0])
_, _, h2 = neuron((x1, x2), gewichte_verborgen[1], bias_verborgen[1])
_, _, y = neuron((h1, h2), gewichte_ausgabe, bias_ausgabe)
klasse = "ja" if y >= 1.0 else "nein"
return (x1, x2), (h1, h2), y, klasse
for wort in ("Katze", "Klee", "Elefant", "Maus"):
eingabe, verborgen, ausgabe, klasse = vorhersage(wort)
print(f"{wort}: x={eingabe} h={verborgen} y={ausgabe:.1f} Klasse={klasse}")
from neuron import neuron
def vorhersage(text):
x1 = int(len(text) >= 5)
x2 = int(text.startswith("K"))
gewichte_verborgen = ((1.0, 1.0), (1.0, 1.0))
bias_verborgen = (-1.0, 0.0)
gewichte_ausgabe = (1.0, 0.5)
bias_ausgabe = 0.0
_, _, h1 = neuron((x1, x2), gewichte_verborgen[0], bias_verborgen[0])
_, _, h2 = neuron((x1, x2), gewichte_verborgen[1], bias_verborgen[1])
_, _, y = neuron((h1, h2), gewichte_ausgabe, bias_ausgabe)
klasse = "ja" if y >= 1.0 else "nein"
return (x1, x2), (h1, h2), y, klasse
for wort in ("Katze", "Klee", "Elefant", "Maus"):
eingabe, verborgen, ausgabe, klasse = vorhersage(wort)
print(f"{wort}: x={eingabe} h={verborgen} y={ausgabe:.1f} Klasse={klasse}")
_, _, h1 übernimmt hier nur den dritten Rückgabewert der Funktion. Die Beiträge und die Zwischensumme benötigen wir an dieser Stelle nicht. h2 und y entstehen auf dieselbe Weise, jeweils mit ihren eigenen Eingaben und Parametern.
Starte das Netz:
python netz.py
python netz.py
Die Ausgabe sollte unverändert sein:
Katze: x=(1, 1) h=(1.0, 2.0) y=2.0 Klasse=ja
Klee: x=(0, 1) h=(0.0, 1.0) y=0.5 Klasse=nein
Elefant: x=(1, 0) h=(0.0, 1.0) y=0.5 Klasse=nein
Maus: x=(0, 0) h=(0.0, 0.0) y=0.0 Klasse=nein
Katze: x=(1, 1) h=(1.0, 2.0) y=2.0 Klasse=ja
Klee: x=(0, 1) h=(0.0, 1.0) y=0.5 Klasse=nein
Elefant: x=(1, 0) h=(0.0, 1.0) y=0.5 Klasse=nein
Maus: x=(0, 0) h=(0.0, 0.0) y=0.0 Klasse=nein
Selbst mit den Zahlen experimentieren
Für die folgenden Versuche änderst du jeweils nur den Funktionsaufruf im Testblock von neuron.py. Notiere zuerst deine Vorhersage und starte dann python neuron.py:
- Eingabe ändern:
neuron((0, 1), (1, 1), -1)ergibt Beiträge[0, 1], Summe0und Ausgabe0.0. - Gewicht ändern:
neuron((1, 1), (-2, 1), -1)ergibt Beiträge[-2, 1], Summe-2und Ausgabe0.0. - Bias ändern:
neuron((1, 1), (1, 1), -2)ergibt Beiträge[1, 1], Summe0und Ausgabe0.0.
Setze den Testaufruf danach wieder auf neuron((1, 1), (1, 1), -1). Diese Änderungen im Testblock verändern das Verhalten von netz.py nicht: Das Netz importiert nur die Funktion und übergibt ihr eigene Eingaben und Parameter. Wenn du dagegen die Funktion selbst veränderst, wirkt sich das auch auf das Netz aus.
Bei ModuleNotFoundError prüfe, ob neuron.py und netz.py beide in ~/eigene-ki liegen und du dort python netz.py aufrufst. Bei ValueError prüfe, ob für jede Eingabe ein Gewicht angegeben ist. SyntaxError verweist auf die betreffende Zeile, etwa bei fehlenden Klammern oder falschen Einrückungen.
Und was ist mit NumPy?
Die einzelnen Multiplikationen sind für unser kleines Netz überschaubar. Bei größeren Netzen wollen wir nicht jede Verbindung einzeln ausschreiben. NumPy bietet Arrays und Operationen für Vektoren und Matrizen, mit denen sich viele dieser Rechnungen kompakt ausdrücken lassen. Es ist eine Rechenbibliothek, kein fertiger Sprachmodell-Baukasten.
Bibliotheken wie PyTorch bieten zusätzlich Bausteine für neuronale Netze und automatische Berechnung von Gradienten. Wir bleiben zunächst bei nachvollziehbarem Python und führen geeignete Werkzeuge später beim Übergang zum Sprachmodell ein. Welche Bibliothek wir für das gemeinsame Projekt verwenden, prüfen wir dann auch auf der Linux-VM.
Wie geht es weiter?
Wir haben nun eine Funktion für eine Neuronenrechnung und verwenden sie an drei Stellen im Netz. Im nächsten Teil verfolgen wir den vollständigen Vorwärtsdurchlauf durch alle Schichten. Später untersuchen wir, wie Training die Gewichte und Bias-Werte verändert.