ef:ki:nn [DokuWiki CSC]

Dies ist eine alte Version des Dokuments!

Nikolai, Adam

Einleitung

Viele kennen neuronale Netzwerke als Diagramme mit Punkten, die in Spalten angeordnet sind und durch Linien miteinander verbunden werden. Auf den ersten Blick wirkt das ziemlich technisch, aber die Grundidee dahinter ist eigentlich leicht zu verstehen. Ein neuronales Netzwerk versucht, Muster in Daten zu erkennen, so wie wir Menschen Dinge wiedererkennen, wenn wir sie oft genug gesehen haben.

In unserem Beispiel besteht das Netzwerk aus drei Schichten. Die erste Schicht hat 784 Eingabewerte. Das können zum Beispiel die einzelnen Pixel eines Bildes sein, auf dem ein Buchstabe zu sehen ist. Diese Informationen gelangen dann in die mittlere Schicht mit 128 Neuronen. Dort versucht das Netzwerk, wichtige Merkmale zu finden wie Linien, Rundungen oder Ecken. Danach geht alles weiter zur Ausgabeschicht mit 52 Neuronen. Jedes dieser Neuronen steht für einen Buchstaben des Alphabets, jeweils in Grossbuchstaben und Kleinbuchstaben. Am Ende entscheidet das Netzwerk, welcher Buchstabe am besten zum eingegebenen Bild passt.

So zeigt das Diagramm sehr anschaulich, wie ein neuronales Netzwerk Informationen verarbeitet und Schritt für Schritt immer näher an die richtige Antwort kommt.

Weiter gehts

Wenn du dir die Grafik anschaust, siehst du auf der linken Seite die lila Kreise. Jeder dieser Kreise ist ein einzelner Neuron, und zusammen bilden sie die Input Layer. Was steckt da drin? Ganz einfach, jeden Pixelwert des Buchstabenbildes, umgerechnet auf einen Wert zwischen 0 und 1:

inputVector = 1.0 - arr.flatten() / 255.0

Weiss wird zu 0.0, schwarz zu 1.0. Und weil das Bild 28×28 Pixel gross ist, entstehen genau 784 Werte, deshalb steht in der Grafik auch x₁, x₂ bis x₇₈₄. Schau jetzt auf die Linien zwischen den lila und den grünen Kreisen. Jede einzelne Linie ist ein Gewicht. Es verbindet jeden Input-Neuron mit jedem Hidden-Neuron und jede Verbindung hat einen eigenen Wert, der bestimmt wie stark dieser Input Einfluss hat. Im Code stecken alle diese Gewichte zusammen in einer Matrix:

self.W1 = np.random.randn(inputSize, hiddenSize) * 0.01

784 Inputs mal 128 Hidden Neurons gibt über 100'000 Gewichte, nur für diesen einen Übergang. Die werden am Anfang zufällig gesetzt und dann durch das Training langsam verbessert. Die grünen Kreise in der Mitte, h₁ bis h₁₂₈, sind die Hidden Layer. Jeder dieser Neuronen nimmt alle 784 Eingabewerte, multipliziert sie mit seinen Gewichten und addiert noch einen Bias dazu. Der Bias ist ein freier Wert der dem Neuron erlaubt seine Schwelle unabhängig vom Input zu verschieben. Mathematisch sieht das so aus:

z=(x1⋅w1)+(x2⋅w2)+…+(x784⋅w784)+b

Und im Code passiert das für alle 128 Neuronen auf einmal:

self.z1 = X @ self.W1 + self.b1

Dieses z ist noch nicht das finale Ergebnis des Neurons. Es ist die rohe gewichtete Summe, auch pre-activation genannt. Ob der Neuron jetzt wirklich etwas weitergibt, entscheidet ReLU. Ist z grösser als 0, kommt der Wert durch. Ist er kleiner, wird er auf 0 gesetzt:

self.a1 = self.relu(self.z1)

Was danach rauskommt fliesst zu den orangen Kreisen rechts in der Grafik, der Output Layer. Dort passiert genau dasselbe nochmal, mit Gewichten W₂ und Bias b₂:

self.z2 = self.a1 @ self.W2 + self.b2

Nur der letzte Schritt ist anders. Statt ReLU kommt jetzt Softmax, der die Rohwerte in Wahrscheinlichkeiten umwandelt. Am Ende gibt jeder der 52 orangen Neuronen eine Wahrscheinlichkeit aus und der Buchstabe mit dem höchsten Wert ist die Vorhersage des Netzes.

Wenn du dir nochmal die Grafik anschaust, steht unter den grünen Kreisen „ReLU Aktivierung“ und unter den orangen „Softmax“. Das sind die zwei Aktivierungsfunktionen im Netz, und sie machen eigentlich sehr unterschiedliche Dinge. Fangen wir mit ReLU an. ReLU steht für Rectified Linear Unit, auf Deutsch in etwa „gleichgerichtete lineare Einheit“. Nachdem ein Neuron seine gewichtete Summe z berechnet hat, wird diese einfach durch ReLU geschickt. Die Regel ist denkbar simpel, ist z grösser als 0, kommt der Wert unverändert durch. Ist z kleiner oder gleich 0, wird er auf 0 gesetzt. Das war's:

def relu(z):

  return np.maximum(0, z)

Mathematisch sieht das so aus:

f(z)={zwenn z>00sonstf(z) = \begin{cases} z & \text{wenn } z > 0
0 & \text{sonst} \end{cases}f(z)={z0wenn z>0sonst

Warum macht man das überhaupt? Ohne eine Aktivierungsfunktion wäre das ganze Netz nur eine einzige grosse lineare Gleichung, egal wie viele Schichten man draufpackt. ReLU bringt die Nichtlinearität rein, die das Netz braucht um wirklich komplexe Muster zu lernen. Ein Neuron der 0 ausgibt ist quasi stumm, er gibt nichts weiter. Ein Neuron der einen positiven Wert ausgibt feuert und beeinflusst die nächste Schicht.

Bei der Output Layer ist ReLU aber nicht mehr geeignet. Dort brauchen wir keine stummen Neuronen, wir brauchen Wahrscheinlichkeiten. Genau das macht Softmax. Er nimmt alle 52 Rohwerte der Output-Neuronen auf einmal und rechnet sie so um, dass sie zusammen 1.0 ergeben:

def softmax(z):

  e = np.exp(z - np.max(z, axis=1, keepdims=True))
  return e / e.sum(axis=1, keepdims=True)

Mathematisch passiert folgendes, jeder Rohwert wird mit der Exponentialfunktion hochgerechnet, und dann durch die Summe aller hochgerechneten Werte geteilt:

σ(zi)=ezi∑j=152ezj\sigma(z_i) = \frac{e^{z_i}}{\sum_{j=1}^{52} e^{z_j}}σ(zi)=∑j=152ezjezi

Das sorgt dafür, dass ein hoher Rohwert eine hohe Wahrscheinlichkeit bekommt und ein tiefer eine kleine. Am Ende schaut das Netz einfach welcher der 52 Neuronen die höchste Wahrscheinlichkeit hat, und das ist dann der vorhergesagte Buchstabe:

labels[np.argmax(probs)]

ReLU und Softmax haben also ganz verschiedene Rollen. ReLU filtert innerhalb des Netzes und schafft die Nichtlinearität. Softmax macht am Schluss aus rohen Zahlen eine lesbare Aussage, nämlich wie sicher das Netz ist, welchen Buchstaben es gerade sieht.

Ein Perzeptron ist eigentlich der Vorläufer von allem was wir bisher besprochen haben. Es ist das einfachste denkbare künstliche Neuron, erfunden in den 1950er Jahren. Die Idee dahinter ist genau dieselbe wie bei unserem Neuron, Inputs reinkommen, mit Gewichten multiplizieren, Bias addieren, und dann eine Entscheidung treffen. Der Unterschied ist, dass ein klassisches Perzeptron am Ende nur 0 oder 1 ausgeben kann, also entweder ja oder nein. Erkenne ich den Buchstaben oder nicht.

Das Problem dabei ist schnell klar. Mit nur 0 und 1 kann man keine Wahrscheinlichkeiten ausdrücken und man kann auch keine komplexen Muster lernen. Ein einzelnes Perzeptron kann zum Beispiel nicht unterscheiden ob ein Pixel oben links oder unten rechts liegt, es sieht alles als eine einzige Entscheidung. Genau deshalb wurde das Feedforward-Netz entwickelt. Die Idee ist simpel, man nimmt nicht ein Perzeptron sondern viele, stapelt sie in Schichten übereinander und verbindet sie. Das ist genau das was du in der Grafik siehst. Die Informationen fliessen dabei immer nur in eine Richtung, von links nach rechts, von der Input Layer durch die Hidden Layer bis zur Output Layer. Kein Rückweg, kein Kreis, nur vorwärts. Daher der Name Feedforward.

Im Code ist dieser Vorwärtsdurchlauf die forward Methode:

def forward(self, X):

  self.z1 = X @ self.W1 + self.b1
  self.a1 = self.relu(self.z1)
  self.z2 = self.a1 @ self.W2 + self.b2
  self.a2 = self.softmax(self.z2)
  return self.a2

Man sieht es schön, zuerst Input Layer zu Hidden Layer, dann Hidden Layer zu Output Layer. Schritt für Schritt nach vorne. Jede Schicht nimmt das Ergebnis der vorherigen, verarbeitet es weiter und gibt es an die nächste weiter.

Der entscheidende Unterschied zum einzelnen Perzeptron ist die Hidden Layer in der Mitte. Dort lernt das Netz nicht mehr nur eine einzige Entscheidung, sondern viele kleine Teilmuster gleichzeitig. Ein Neuron lernt vielleicht auf geschwungene Linien zu reagieren, ein anderes auf senkrechte Striche, wieder ein anderes auf geschlossene Formen. Zusammen können diese 128 Neuronen dann auch komplexe Buchstaben wie G oder R auseinanderhalten, was ein einzelnes Perzeptron niemals könnte.

Die gewichtete Summe ist der erste Schritt den jeder Neuron macht. Er nimmt alle seine Inputs, multipliziert jeden mit seinem zugehörigen Gewicht und addiert alles zusammen. Das Gewicht entscheidet dabei wie wichtig ein Input ist. Ein Pixel der für die Erkennung eines bestimmten Buchstabens sehr relevant ist bekommt ein hohes Gewicht, ein unwichtiger Pixel ein niedriges. Im Code landet das alles in dieser einen Zeile:

self.z1 = X @ self.W1 + self.b1

Das Ergebnis z ist einfach eine Zahl, die zusammenfasst was der Neuron aus allen seinen Inputs herausgelesen hat.

Jetzt kommt der Schwellenwert ins Spiel. Man kann sich das vorstellen wie eine Eingangstür. Nur wenn die gewichtete Summe gross genug ist, also den Schwellenwert überschreitet, gibt der Neuron etwas weiter. Bei ReLU ist dieser Schwellenwert genau 0. Ist z grösser als 0, kommt der Wert durch. Ist z kleiner oder gleich 0, wird alles auf 0 gesetzt und der Neuron bleibt stumm:

self.a1 = self.relu(self.z1)

Der Schwellenwert ist also nicht irgendeine komplizierte Einstellung, sondern schlicht die Grenze zwischen feuern und nicht feuern.

Und genau da kommen wir zur Entscheidungsgrenze. Das ist das was das ganze Netz letztendlich lernt. Durch das Training mit vielen Buchstabenbildern passen sich die Gewichte so an, dass das Netz den Raum aller möglichen Inputs aufteilt. Auf der einen Seite der Grenze liegt zum Beispiel ein „a“, auf der anderen ein „o“. Diese Grenze ist nicht gerade wie eine Linie auf einem Blatt Papier, sie ist hochdimensional und sehr komplex. Genau deshalb braucht man ReLU, denn ohne Aktivierungsfunktion könnte das Netz nur gerade Linien als Entscheidungsgrenze lernen, was für Buchstaben bei weitem nicht ausreicht. Mit ReLU kann es gebogene, verschachtelte und viel feinere Grenzen ziehen, und dadurch auch ähnliche Buchstaben wie „c“ und „e“ oder „i“ und „l“ sauber voneinander trennen.

Fangen wir ganz klein an, mit einem einzigen Neuron. Stell dir vor das Netz sagt „b“ aber die richtige Antwort wäre „a“. Das Netz hat also einen Fehler gemacht. Backpropagation ist nichts anderes als die Frage: welches Gewicht war schuld daran, und wie stark?

Der erste Schritt ist den Fehler zu messen. Das macht die Loss Function, in unserem Fall Cross Entropy Loss:

def crossEntropyLoss(probs, yOnehot):

  return -np.mean(np.sum(yOnehot * np.log(np.clip(probs, 1e-12, 1.0)), axis=1))

Mathematisch gesehen berechnet sie wie weit die vorhergesagte Wahrscheinlichkeit vom richtigen Wert entfernt ist:

L=−∑iyi⋅log⁡(y^i)L = -\sum_{i} y_i \cdot \log(\hat{y}_i)L=−i∑yi⋅log(y^i)

War die Vorhersage für „a“ zum Beispiel nur 0.02 obwohl sie 1.0 sein sollte, ist der Loss gross. War sie 0.95, ist der Loss klein. Jetzt wissen wir wie gross der Fehler ist, aber noch nicht woher er kommt.

Hier kommt der Gradient ins Spiel. Ein Gradient sagt uns für jedes einzelne Gewicht, in welche Richtung und wie stark es den Loss beeinflusst. Man kann sich das wie ein Hügel vorstellen. Der Loss ist die Höhe, und wir wollen den tiefsten Punkt finden. Der Gradient zeigt uns die steilste Richtung bergauf, also gehen wir genau die entgegengesetzte Richtung bergab. Das nennt sich Gradientenabstieg.

Bei einem einzelnen Neuron ist das noch überschaubar. Angenommen wir haben einen Output-Neuron mit nur einem Gewicht w. Der Fehler am Ausgang ist einfach die Differenz zwischen Vorhersage und richtigem Wert:

δ=y^−y\delta = \hat{y} - yδ=y^−y

Das Gewicht w hat diesen Fehler verursacht, proportional dazu wie gross der Input x war. Also ist der Gradient:

∂L∂w=δ⋅x\frac{\partial L}{\partial w} = \delta \cdot x∂w∂L=δ⋅x

Und das Gewicht wird dann in die entgegengesetzte Richtung angepasst:

wneu=walt−η⋅∂L∂ww_{neu} = w_{alt} - \eta \cdot \frac{\partial L}{\partial w}wneu=walt−η⋅∂w∂L

Wobei η\eta η die Lernrate ist, also wie gross jeder Schritt bergab ist. Im Code ist das:

self.lr = learningRate

Soweit so gut für einen einzelnen Neuron. Aber jetzt kommt die eigentliche Herausforderung.

In unserem Netz hat kein Gewicht in der Hidden Layer einen direkten Kontakt zum Fehler am Ausgang. Die Hidden Layer sieht den Fehler nicht direkt, sie hat ihn nur indirekt mitverursacht. Backpropagation löst genau dieses Problem, indem es den Fehler rückwärts durch das Netz schickt, Schicht für Schicht. Zuerst wird der Fehler an der Output Layer berechnet. Das ist noch einfach, Vorhersage minus richtige Antwort:

d2 = self.a2 - yOnehot

Mathematisch:

δ2=y^−y\delta_2 = \hat{y} - yδ2=y^−y

Jetzt muss dieser Fehler zurück durch die Gewichte W₂ in die Hidden Layer propagiert werden. Dazu wird d2 mit der transponierten Gewichtsmatrix multipliziert:

δ1=(δ2⋅W2T)⋅ReLU′(z1)\delta_1 = (\delta_2 \cdot W_2^T) \cdot \text{ReLU}'(z_1)δ1=(δ2⋅W2T)⋅ReLU′(z1)

Das ReLU' ist die Ableitung von ReLU, also die reluDerivative. Sie sorgt dafür dass nur die Neuronen einen Fehleranteil zugewiesen bekommen, die vorhin auch wirklich gefeuert haben. Neuronen die 0 ausgegeben haben bekommen auch 0 Fehler zurück, denn sie haben nichts beigetragen:

d1 = (d2 @ self.W2.T) * self.reluDerivative(self.z1)

Jetzt kennt jede Schicht ihren Fehleranteil. Damit können alle Gewichte und Biases aktualisiert werden:

self.W2 -= self.lr * (self.a1.T @ d2) / N self.b2 -= self.lr * d2.mean(axis=0) self.W1 -= self.lr * (X.T @ d1) / N self.b1 -= self.lr * d1.mean(axis=0)

Mathematisch passiert hier für jede Schicht dasselbe wie beim einzelnen Neuron, nur jetzt für alle Gewichte gleichzeitig:

W2=W2−η⋅a1T⋅δ2NW_2 = W_2 - \eta \cdot \frac{a_1^T \cdot \delta_2}{N}W2=W2−η⋅Na1T⋅δ2

W1=W1−η⋅XT⋅δ1NW_1 = W_1 - \eta \cdot \frac{X^T \cdot \delta_1}{N}W1=W1−η⋅NXT⋅δ1

Das Division durch N ist dabei wichtig, es mittelt den Fehler über alle Trainingsbeispiele im Batch, damit kein einzelnes Bild zu viel Einfluss hat. Dieser ganze Prozess, Forward Pass, Loss berechnen, Fehler zurückpropagieren, Gewichte anpassen, wiederholt sich dann für jeden Batch und jede Epoche:

for epoch in range(epochs):

  for start in range(0, N, batchSize):
      probs = self.forward(Xs[start:end])
      epochLoss += self.crossEntropyLoss(probs, Ys[start:end])
      self.backward(Xs[start:end], Ys[start:end])

Nach hunderten von Epochen haben sich die Gewichte so weit angepasst, dass das Netz die meisten Buchstaben richtig erkennt. Backpropagation ist also im Grunde nur eine sehr clevere Art, die Schuld für einen Fehler auf alle Beteiligten aufzuteilen und jeden ein kleines Stück besser zu machen.

Die Input Layer ist der Eingang des Netzes. Hier kommt das Bild rein, nichts weiter. Jeder Pixel wird zu einem Neuron, und weil unsere Bilder 28×28 Pixel gross sind, hat diese Schicht genau 784 Neuronen. Sie rechnet nichts, sie bewertet nichts, sie gibt einfach die rohen Pixelwerte weiter. In der Grafik sind das die lila Kreise ganz links, beschriftet mit x₁ bis x₇₈₄. Die Hidden Layer ist dort wo das eigentliche Lernen passiert. Sie liegt in der Mitte, zwischen Input und Output, und ist von aussen nicht direkt sichtbar, daher der Name. Ihre 128 Neuronen nehmen alle 784 Eingabewerte, berechnen daraus ihre gewichteten Summen und entscheiden via ReLU ob sie feuern oder nicht. Mit der Zeit lernt jedes dieser Neuronen auf bestimmte Muster zu reagieren, geschwungene Linien, senkrechte Striche, geschlossene Formen. In der Grafik sind das die grünen Kreise in der Mitte. Im Code wird die Grösse dieser Schicht so festgelegt:

self.W1 = np.random.randn(inputSize, hiddenSize) * 0.01

Die Output Layer ist die letzte Schicht und gibt die finale Antwort des Netzes. Sie hat genau 52 Neuronen, eines pro Buchstabe von a bis Z. Jedes dieser Neuronen gibt eine Wahrscheinlichkeit aus, wie sicher das Netz ist dass der gesehene Buchstabe dieser Klasse entspricht. Der Buchstabe mit der höchsten Wahrscheinlichkeit ist dann die Vorhersage. In der Grafik sind das die orangen Kreise ganz rechts. Im Code:

self.W2 = np.random.randn(hiddenSize, outputSize) * 0.01

Ein tiefes neuronales Netz, auf Englisch Deep Neural Network, ist im Grunde nichts anderes als ein Netz mit mehreren Hidden Layers hintereinander. Statt einer einzigen mittleren Schicht wie in unserem Code hat ein tiefes Netz vielleicht fünf, zehn oder sogar hunderte davon. Jede Schicht lernt dabei etwas ein bisschen Abstrakteres als die vorherige. Die erste Hidden Layer erkennt vielleicht einfache Kanten und Striche, die zweite kombiniert diese zu Kurven und Ecken, die dritte erkennt daraus ganze Buchstabenteile, und so weiter. Je tiefer das Netz, desto komplexere Konzepte kann es verstehen.

Genau da liegt der Unterschied zu einem flachen Netz. Ein flaches Netz hat nur eine oder sehr wenige Hidden Layers, so wie unseres mit genau einer. Es kann durchaus funktionieren, und für unsere Aufgabe der Buchstabenerkennung reicht es gut aus. Aber es hat eine natürliche Grenze. Mit nur einer Hidden Layer muss das Netz alle Muster auf einmal lernen, ohne sie in kleinere Teilprobleme aufzuteilen. Das wird schnell schwierig wenn die Aufgabe komplexer wird.

Ein tiefes Netz löst das indem es die Arbeit auf viele Schichten verteilt. Jede Schicht baut auf der vorherigen auf und abstrahiert weiter. Das ist auch der Grund warum moderne KI-Modelle für Bilderkennung, Sprachverarbeitung oder Übersetzungen so gut funktionieren, sie sind extrem tief. GPT, das Modell hinter vielen Chatbots, hat zum Beispiel nicht 128 Neuronen in einer Schicht sondern Milliarden von Parametern verteilt über viele Schichten.

Der Nachteil dabei ist dass tiefe Netze viel mehr Daten, viel mehr Rechenleistung und viel mehr Zeit zum Trainieren brauchen. Unser flaches Netz mit 784 Inputs, 128 Hidden Neurons und 52 Outputs hat knapp 102'000 Parameter. Ein modernes Deep Learning Modell hat davon Milliarden. Für eine einfache Aufgabe wie unsere wäre das völlig übertrieben, weshalb ein flaches Netz hier die richtige Wahl ist.

künstliches Neuron
Input
Gewicht
Bias
Aktivierungsfunktion
Perzeptron
Feedforward-Netz
gewichtete Summe
Schwellenwert
Entscheidungsgrenze
Backpropagation
Input Layer
Hidden Layer
Output Layer
Tiefe neuronale Netze (Deep Neural Networks)
flache vs. tiefe Netze

Evtl. ein ganz simples Beispiel zeigen und durchgehen (AND).