Ein Neuron lernt

1. Die Pinguine

Auf den Inseln vor der Antarktischen Halbinsel hat die Biologin Kristen Gorman von 2007 bis 2009 Pinguine vermessen: ihre Art, ihr Gewicht, die Länge ihrer Flossen und ihren Schnabel. Drei Arten leben dort: der Zügelpinguin (englisch Chinstrap), der Eselspinguin (Gentoo) und der Adéliepinguin.

Der Adéliepinguin und der Eselspinguin sehen sich auf den ersten Blick ähnlich. Am Schnabel kann man sie unterscheiden, wenn man weiß, worauf man achten muss. Gemessen wurde er so:

Du wirst ein Programm schreiben, das diese Regel selbst findet, nur aus den Messungen und der Art jedes Pinguins. Niemand sagt ihm, worauf es achten soll.

2. Ein künstliches Neuron

Eine Nervenzelle im Gehirn bekommt Signale von anderen Zellen, manche stärker, manche schwächer. Kommt insgesamt genug zusammen, feuert sie selbst ein Signal. Ein künstliches Neuron rechnet das nach, in drei Schritten:

1. Jede Eingabe wird mit ihrem Gewicht multipliziert. Ein großes Gewicht heißt: Diese Eingabe zählt viel; ein negatives: Sie spricht dagegen.
2. Die Produkte werden addiert, dazu kommt eine feste Zahl, der Bias.
3. Ist die Summe größer als 0, sagt das Neuron 1, sonst 0.

Für einen Pinguin sind die Eingaben die Länge und die Höhe seines Schnabels in Millimetern, und 1 heißt Eselspinguin, 0 Adéliepinguin. Mit den Gewichten 2 und −5 und dem Bias 10 rechnet das Neuron für einen Schnabel, der 50 mm lang und 15 mm hoch ist:

$$2 \cdot 50 + (-5) \cdot 15 + 10 = 100 - 75 + 10 = 35$$

35 ist größer als 0: Das Neuron sagt 1, ein Eselspinguin.

Das erste solche Neuron beschrieben der Neurologe Warren McCulloch und der Logiker Walter Pitts 1943, auf Papier. Frank Rosenblatt baute 1958 eines, das seine Gewichte selbst einstellte: das Perzeptron.

Frank Rosenblatt (1928–1971), US-amerikanischer Psychologe an der Cornell University. 1958 baute er das Mark I Perceptron: eine Kamera aus 20 × 20 Fotozellen, also 400 Eingaben, deren Gewichte Motoren an Drehwiderständen selbst einstellten. Die Maschine lernte, einfache Formen auseinanderzuhalten.

Deine Funktion train lernt nach seiner Regel: bei jedem Fehler die Gewichte ein Stück in Richtung der richtigen Antwort.

Foto: unbekannt, um 1950, Heinz Nixdorf MuseumsForum, CC BY-SA 4.0, zugeschnitten (Wikimedia Commons)

3. Einrichten

mkdir -p ~/perzeptron
cd ~/perzeptron
wget https://workspace.hackschule.de/perzeptron/penguins.csv
touch neuron.rb learn.rb

irb -r ./neuron.rb

mkdir -p ~/perzeptron
cd ~/perzeptron
wget https://workspace.hackschule.de/perzeptron/penguins.csv
touch neuron.py learn.py

python3 -i neuron.py

penguins.csv hat eine Zeile je Pinguin, 342 Zeilen: die Art, die Insel, die Länge und die Höhe des Schnabels in Millimetern, die Länge der Flosse und das Gewicht in Gramm.

species,island,bill_length_mm,bill_depth_mm,flipper_length_mm,body_mass_g
Adelie,Torgersen,39.1,18.7,181,3750

4. Das Neuron entscheidet

# 1 oder 0: ist die gewichtete Summe der Merkmale plus Bias größer als 0?
def predict(weights, bias, features)
  sum = bias
  features.each_index do |i|
    sum += weights[i] * features[i]
  end
  sum > 0 ? 1 : 0
end

# 1 oder 0: ist die gewichtete Summe der Merkmale plus Bias größer als 0?
def predict(weights, bias, features):
    total = bias
    for i in range(len(features)):
        total += weights[i] * features[i]
    return 1 if total > 0 else 0

Damit das Neuron die Pinguine sieht, liest diese Funktion die Datei. Sie gibt für jeden Pinguin der beiden Arten ein Paar zurück: die zwei Maße des Schnabels und die Art als Zahl, 1 für die zweite der beiden Arten, 0 für die erste. Schreib sie unter predict in dieselbe Datei:

# Die Pinguine zweier Arten als [[Länge, Höhe], 0 oder 1]
def penguins(path, species)
  File.readlines(path).drop(1).filter_map do |line|
    name, _island, length, depth = line.split(",")
    next unless species.include?(name)

    [[length.to_f, depth.to_f], name == species[1] ? 1 : 0]
  end
end

# Die Pinguine zweier Arten als [[Länge, Höhe], 0 oder 1]
def penguins(path, species):
    examples = []
    for line in open(path).readlines()[1:]:
        name, _island, length, depth = line.split(",")[:4]
        if name in species:
            examples.append([[float(length), float(depth)], 1 if name == species[1] else 0])
    return examples

5. Lernen aus Fehlern

Woher kommen die Gewichte? Am Anfang sind alle 0, und das Neuron sagt zu jedem Pinguin 0. Dann geht es die Pinguine einen nach dem anderen durch und vergleicht, was es sagt, mit der richtigen Art. Liegt es richtig, ändert es nichts. Liegt es falsch, verschiebt es seine Gewichte ein Stück in die Richtung der richtigen Antwort:

• Hat es 0 gesagt, aber 1 wäre richtig, addiert es die Merkmale des Pinguins zu seinen Gewichten und 1 zum Bias. Beim nächsten Mal wird seine Summe für einen ähnlichen Pinguin größer.
• Hat es 1 gesagt, aber 0 wäre richtig, zieht es sie ab, und 1 vom Bias.

Kurz: Der Fehler ist die richtige Antwort minus die Vorhersage, also 1, −1 oder 0, und jedes Gewicht bekommt Fehler mal Merkmal dazu, der Bias den Fehler.

$$w_i \leftarrow w_i + (t - y) \cdot x_i \qquad b \leftarrow b + (t - y)$$

Ein Durchgang durch alle Pinguine heißt Epoche. Nach einer Epoche fängt das Neuron wieder vorne an, bis es in einer ganzen Epoche keinen Fehler mehr macht.

def train(examples, epochs)
  weights = Array.new(examples[0][0].size, 0.0)
  bias = 0.0
  epochs.times do |epoch|
    errors = 0
    examples.each do |features, target|
      # hier: vorhersagen, den Fehler ausrechnen, bei einem Fehler
      # weights und bias ändern und errors zählen
    end
    puts "Epoche #{epoch + 1}: #{errors} Fehler"
    break if errors == 0
  end
  [weights, bias]
end

# Lernt Gewichte und Bias aus Beispielen [Merkmale, 0 oder 1], höchstens epochs Epochen lang
def train(examples, epochs)
  weights = Array.new(examples[0][0].size, 0.0)
  bias = 0.0
  epochs.times do |epoch|
    errors = 0
    examples.each do |features, target|
      error = target - predict(weights, bias, features)
      next if error == 0

      features.each_index do |i|
        weights[i] += error * features[i]
      end
      bias += error
      errors += 1
    end
    puts "Epoche #{epoch + 1}: #{errors} Fehler"
    break if errors == 0
  end
  [weights, bias]
end

def train(examples, epochs):
    weights = [0.0] * len(examples[0][0])
    bias = 0.0
    for epoch in range(epochs):
        errors = 0
        for features, target in examples:
            # hier: vorhersagen, den Fehler ausrechnen, bei einem Fehler
            # weights und bias ändern und errors zählen
            ...
        print(f"Epoche {epoch + 1}: {errors} Fehler")
        if errors == 0:
            break
    return weights, bias

# Lernt Gewichte und Bias aus Beispielen [Merkmale, 0 oder 1], höchstens epochs Epochen lang
def train(examples, epochs):
    weights = [0.0] * len(examples[0][0])
    bias = 0.0
    for epoch in range(epochs):
        errors = 0
        for features, target in examples:
            error = target - predict(weights, bias, features)
            if error == 0:
                continue
            for i in range(len(features)):
                weights[i] += error * features[i]
            bias += error
            errors += 1
        print(f"Epoche {epoch + 1}: {errors} Fehler")
        if errors == 0:
            break
    return weights, bias

require_relative "neuron"

examples = penguins("penguins.csv", ["Adelie", "Gentoo"])
weights, bias = train(examples, 100)
puts "Gewichte: #{weights.map { |w| w.round(1) }}, Bias: #{bias.round(1)}"

ruby learn.rb

from neuron import *

examples = penguins("penguins.csv", ["Adelie", "Gentoo"])
weights, bias = train(examples, 100)
print(f"Gewichte: {[round(w, 1) for w in weights]}, Bias: {round(bias, 1)}")

python3 learn.py

6. Was das Neuron gelernt hat

Die Pinguine, für die die Summe genau 0 ist, liegen auf einer Geraden. Auf der einen Seite sagt das Neuron 0, auf der anderen 1. Diese Funktion zeichnet die Pinguine und die Gerade in eine Datei plot.svg, die VS Code als Bild öffnet. Ein SVG-Bild ist Text, Kreise und Linien mit ihren Koordinaten; wie es aufgebaut ist, steht im Handbuch unter SVG:

# Die Beispiele als Punkte (Länge nach rechts, Höhe nach oben) und die Gerade,
# auf der die Summe des Neurons 0 ist, als SVG in path
def plot(examples, weights, bias, path)
  x0, x1, y0, y1 = 30.0, 62.0, 12.0, 23.0
  sx = ->(x) { (x - x0) / (x1 - x0) * 600 + 40 }
  sy = ->(y) { 440 - (y - y0) / (y1 - y0) * 400 }
  svg = ["<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 680 480'>",
         "<rect width='680' height='480' fill='white'/>"]
  examples.each do |(length, depth), target|
    colour = target == 1 ? "#2b5fb4" : "#d97706"
    svg << "<circle cx='#{sx.(length)}' cy='#{sy.(depth)}' r='4' fill='#{colour}'/>"
  end
  if weights[1] != 0
    ya = -(weights[0] * x0 + bias) / weights[1]
    yb = -(weights[0] * x1 + bias) / weights[1]
    svg << "<line x1='#{sx.(x0)}' y1='#{sy.(ya)}' x2='#{sx.(x1)}' y2='#{sy.(yb)}' stroke='black' stroke-width='2'/>"
  end
  svg << "</svg>"
  File.write(path, svg.join("\n"))
end

plot(examples, weights, bias, "plot.svg")

# Die Beispiele als Punkte (Länge nach rechts, Höhe nach oben) und die Gerade,
# auf der die Summe des Neurons 0 ist, als SVG in path
def plot(examples, weights, bias, path):
    x0, x1, y0, y1 = 30.0, 62.0, 12.0, 23.0
    def sx(x):
        return (x - x0) / (x1 - x0) * 600 + 40
    def sy(y):
        return 440 - (y - y0) / (y1 - y0) * 400
    svg = ["<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 680 480'>",
           "<rect width='680' height='480' fill='white'/>"]
    for (length, depth), target in examples:
        colour = "#2b5fb4" if target == 1 else "#d97706"
        svg.append(f"<circle cx='{sx(length)}' cy='{sy(depth)}' r='4' fill='{colour}'/>")
    if weights[1] != 0:
        ya = -(weights[0] * x0 + bias) / weights[1]
        yb = -(weights[0] * x1 + bias) / weights[1]
        svg.append(f"<line x1='{sx(x0)}' y1='{sy(ya)}' x2='{sx(x1)}' y2='{sy(yb)}' stroke='black' stroke-width='2'/>")
    svg.append("</svg>")
    with open(path, "w") as f:
        f.write("\n".join(svg))

plot(examples, weights, bias, "plot.svg")

7. Pinguine, die das Neuron nie gesehen hat

Dass das Neuron alle Pinguine richtig einordnet, aus denen es gelernt hat, sagt noch nicht viel: Vielleicht hat es sich nur genau diese gemerkt. Ob es die Regel gelernt hat, zeigt sich an Pinguinen, die es nie gesehen hat. Darum lernt es jetzt nur aus jedem zweiten Pinguin und wird an den anderen geprüft.

# Der Anteil der Beispiele, die das Neuron richtig einordnet
def accuracy(weights, bias, examples)
  right = examples.count { |features, target| predict(weights, bias, features) == target }
  right.to_f / examples.size
end

# Der Anteil der Beispiele, die das Neuron richtig einordnet
def accuracy(weights, bias, examples):
    right = sum(1 for features, target in examples if predict(weights, bias, features) == target)
    return right / len(examples)

examples = penguins("penguins.csv", ["Adelie", "Gentoo"])training = examples.select.with_index { |_, i| i.even? }test = examples.select.with_index { |_, i| i.odd? }weights, bias = train(training, 100)puts "Richtig bei Pinguinen, die es nie gesehen hat: #{(accuracy(weights, bias, test) * 100).round(1)} %"

examples = penguins("penguins.csv", ["Adelie", "Gentoo"])training = examples[0::2]test = examples[1::2]weights, bias = train(training, 100)print(f"Richtig bei Pinguinen, die es nie gesehen hat: {round(accuracy(weights, bias, test) * 100, 1)} %")

8. Wo ein Neuron nicht weiterkommt

Auf der Insel Dream lebt eine dritte Art, der Zügelpinguin (englisch Chinstrap). Kann das Neuron ihn vom Adéliepinguin unterscheiden?

Das gilt auch für Aufgaben, bei denen es keinen einzigen Ausreißer gibt. Das bekannteste Beispiel ist XOR, »entweder oder«: Die Antwort ist 1, wenn genau eine von zwei Eingaben 1 ist.

Die vier Punkte liegen an den Ecken eines Quadrats, die beiden mit der Antwort 1 schräg gegenüber. Keine Gerade hat die beiden 1 auf der einen und die beiden 0 auf der anderen Seite. Das bewiesen Marvin Minsky und Seymour Papert 1969 in ihrem Buch »Perceptrons«, und für viele Jahre glaubte kaum jemand mehr an lernende Neuronen.

Die Lösung kam später: mehrere Neuronen in Schichten hintereinander. Zwei Neuronen in einer ersten Schicht ziehen zwei Geraden, ein drittes dahinter entscheidet aus ihren Antworten. So geht XOR, und mit vielen Schichten und Millionen von Neuronen gehen auch Bilder, Sprache und Spiele. Wie man die Gewichte vieler Schichten lernt, ist schwieriger als bei einem einzelnen Neuron und kam erst in den 1980er Jahren in Gang.

9. Ziffern lesen

Dein Neuron kennt nichts von Pinguinen. Es nimmt Zahlen, multipliziert sie mit Gewichten und vergleicht die Summe mit 0. Ob die Zahlen Schnäbel sind oder etwas anderes, ist ihm gleich.

Handgeschriebene Ziffern, auf 8 mal 8 Kästchen verkleinert, sind 64 Zahlen: wie dunkel jedes Kästchen ist, von 0 (weiß) bis 16 (schwarz). 43 Menschen haben dafür Ziffern geschrieben, Forschende an der Universität Boğaziçi in Istanbul haben sie 1998 gesammelt. Zwei Dateien: Aus digits-train.csv lernt das Neuron, an digits-test.csv wird es geprüft, mit Ziffern von Menschen, deren Handschrift es nie gesehen hat. Jede Zeile hat 65 Zahlen, die 64 Kästchen Zeile für Zeile und am Ende die Ziffer.

wget https://workspace.hackschule.de/perzeptron/digits-train.csv https://workspace.hackschule.de/perzeptron/digits-test.csv

# Die Ziffern a und b als [64 Kästchen, 0 für a oder 1 für b]
def digits(path, a, b)
  File.readlines(path).filter_map do |line|
    values = line.split(",").map(&:to_i)
    next unless [a, b].include?(values[64])

    [values[0, 64], values[64] == b ? 1 : 0]
  end
end

# Die Ziffern a und b als [64 Kästchen, 0 für a oder 1 für b]
def digits(path, a, b):
    examples = []
    for line in open(path):
        values = [int(v) for v in line.split(",")]
        if values[64] in (a, b):
            examples.append([values[:64], 1 if values[64] == b else 0])
    return examples

training = digits("digits-train.csv", 0, 1)
test = digits("digits-test.csv", 0, 1)
weights, bias = train(training, 100)
puts "Richtig bei fremden Handschriften: #{(accuracy(weights, bias, test) * 100).round(1)} %"

training = digits("digits-train.csv", 0, 1)
test = digits("digits-test.csv", 0, 1)
weights, bias = train(training, 100)
print(f"Richtig bei fremden Handschriften: {round(accuracy(weights, bias, test) * 100, 1)} %")

Was das Neuron sieht

Die 64 Gewichte gehören zu den 64 Kästchen. Ein großes positives Gewicht heißt: Ist dieses Kästchen dunkel, spricht das für die zweite Ziffer; ein negatives: für die erste. Zeichnest du die Gewichte als 8 mal 8 Kästchen, blau für positiv und orange für negativ, siehst du, worauf das Neuron achtet.

# Die 64 Gewichte als 8 × 8 Kästchen, blau positiv, orange negativ, als SVG in path
def picture(weights, path)
  top = weights.map(&:abs).max
  svg = ["<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 160 160'>"]
  weights.each_with_index do |w, i|
    colour = w > 0 ? "43,95,180" : "217,119,6"
    opacity = (w.abs / top).round(2)
    svg << "<rect x='#{i % 8 * 20}' y='#{i / 8 * 20}' width='20' height='20' fill='rgb(#{colour})' fill-opacity='#{opacity}'/>"
  end
  svg << "</svg>"
  File.write(path, svg.join("\n"))
end

# Die 64 Gewichte als 8 × 8 Kästchen, blau positiv, orange negativ, als SVG in path
def picture(weights, path):
    top = max(abs(w) for w in weights)
    svg = ["<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 160 160'>"]
    for i, w in enumerate(weights):
        colour = "43,95,180" if w > 0 else "217,119,6"
        opacity = round(abs(w) / top, 2)
        svg.append(f"<rect x='{i % 8 * 20}' y='{i // 8 * 20}' width='20' height='20' fill='rgb({colour})' fill-opacity='{opacity}'/>")
    svg.append("</svg>")
    with open(path, "w") as f:
        f.write("\n".join(svg))

Deine eigene Handschrift

Das Neuron hat aus den Ziffern von 30 Menschen gelernt. Erkennt es auch deine? Dafür bringst du dein Neuron hierher, auf die Seite. Lass dein Programm, nachdem es 0 gegen 1 gelernt hat, die 64 Gewichte und den Bias ausgeben, als eine Zeile mit 65 Zahlen; schreib dazu ans Ende deines Programms:

puts (weights + [bias]).join(" ")

print(" ".join(str(v) for v in weights + [bias]))

Dann:

1. Kopiere die Zeile mit den 65 Zahlen aus dem Terminal in das Feld unter der Zeichenfläche.
2. Zeichne eine Ziffer. Unter dem Feld steht, was dein Neuron dazu sagt, und es ändert sich, während du zeichnest.

Wie bei den Ziffern, aus denen das Neuron gelernt hat, wird deine Zeichnung auf 32 mal 32 Punkte gebracht, so dass sie die Fläche füllt, und daraus werden die 64 Werte. Hast du noch kein Neuron, nimm das Beispiel: Es hat 0 gegen 1 gelernt, so wie dein Neuron mit dem Programm oben.

10. Zum Nachschlagen

• Katas: Listen: Listen durchgehen, mit Index und ohne
• Die Pinguine: Kristen Gorman, Tony Williams und William Fraser, »Ecological Sexual Dimorphism and Environmental Variability within a Community of Antarctic Penguins«, PLOS ONE, 2014; die Daten unter CC0 im Paket palmerpenguins
• Die Ziffern: Optical Recognition of Handwritten Digits, E. Alpaydin und C. Kaynak, 1998, im UCI Machine Learning Repository, unter CC BY 4.0