Datenanalyse

Neuronales Netz

Neuronale Netze versuchen die Vernetzung der Neuronen im Gehirn nachzubilden. Sie sind damit ein Verfahren der künstlichen Intelligenz (KI).

Bild 1 zeigt ein neuronales Netz mit drei Schichten von Neuronen. In dieser Darstellung fließen die Daten von oben nach unten durch das Netz. Jedes Neuron bildet die Summe der an seinen Eingängen anliegenden Werte und berechnet daraus ein Aktivierungspotenzial. Diesen Wert gibt es an alle Neuronen der nächsten Schicht weiter, jeweils mit einem gewissen Faktor gewichtet. Das "Wissen" des neuronalen Netzes, welches es in der Trainingsphase ansammelt, besteht aus nichts anderem als den Werten dieser Gewichte.

Bevor also ein neuronales Netz etwas Sinnvolles tun kann, muss es trainiert werden. In der Trainingsphase oder auch Lernphase werden in der Eingabeschicht bestimmte Werte eingegeben. Dann wird kontrolliert, was das neuronale Netz in der Ausgabeschicht ausgibt, und dies wird mit dem gewünschten Ergebnis verglichen. Die Abweichung wird in das neuronale Netz zurückgespeist (backpropagation), um die Werte der Gewichte zu verbessern. Das Ganze wird zig-tausend Mal mit unterschiedlichen Werten wiederholt, um die Gewichte immer feiner auszutarieren. Die Trainingsphase eines neuronalen Netzes ist entsprechend rechenaufwendig.

Bild 1: Neuronales Netz mit drei Schichten

An den Eingängen der Neuronen der Eingabeschicht wird ein Muster eingegeben, dies ist ein Vektor von reellen Zahlen, der Eingabevektor. Die Neuronen der Eingabeschicht berechnen daraus jeweils für sich ein Aktivierungspotenzial, dies ist eine reelle Zahl zwischen 0 und 1. Diesen Wert geben sie über die Verbindungen an die Neuronen der nächsten Schicht weiter.

Die Verbindungen zwischen Neuronen sind mit reellen Zahlen gewichtet. Die Neuronen der jeweils nächsten Schicht bilden somit die Summe der gewichteten Aktivierungspotenziale der Neuronen der vorherigen Schicht. Aus diesem Wert berechnen sie jeweils ebenfalls ihr Aktivierungspotenzial. Genauso geht es dann zur nächsten Schicht weiter.

Die Neuronen der Ausgabeschicht zeigen an ihren Ausgängen jeweils ihr Aktivierungspotenzial. Zusammengenommen ergibt sich ein Ausgabevektor. Anhand dieses Ausgabevektors soll das neuronale Netz das Muster, das eingegeben wurde, erkennen. Genauer gesagt soll es unterschiedliche ähnliche Muster klassifizieren, also beispielsweise handgeschriebene Ziffern den Werten 0, ..., 9 zuordnen.

Schwellenwertfunktion σ

Die Neuronen berechnen ihr Aktivierungspotenzial aus der Summe ihrer Eingabewerte mit einer Art von Schwellenwertfunktion σ. Das Aktivierungspotenzial der einzelnen Neuronen wird dadurch auf einen Wert zwischen 0 und 1 normalisiert. Häufig wird für σ die folgende Funktion gewählt:

σ(x) =

1 + e^-x

Bild 2 zeigt die Funktion σ(x).

Bild 2: Funktion σ(x) = 1 / (1 + e-x)

Bild 2: Funktion σ(x) = 1 / (1 + e^-x)

Für die mathematische Formulierung der Berechnungen und später für die Implementierung als Computerprogramm sind sehr genaue Bezeichnungsweisen erforderlich; diese werden im Folgenden angegeben.

Schön ist es nicht, aber im Folgenden notwendig, nämlich Indizes hochgestellt zu schreiben. Während untere Indizes auf die Komponenten einer Struktur verweisen, dient der obere Index dazu, diese Strukturen zu unterscheiden. Hier sind diese Strukturen die Schichten des neuronalen Netzes, und die Komponenten sind die einzelnen Neuronen dieser Schicht. Somit wird beispielsweise der Ausgabewert des Neurons j in Schicht r mit s_j^(r) bezeichnet. Obere Indizes stehen dabei immer in Klammern, um Verwechslungen mit Exponenten zu vermeiden.

Bezeichnungen

`n`		Anzahl der Schichten des neuronalen Netzes
`m`^(r)		Anzahl der Neuronen in Schicht `r`, `r` ∈ {0, ..., `n`-1}
`e`_j^(r)		Eingabewert für Neuron `j` in Schicht `r`
`s`_j^(r)		Ausgabewert für Neuron `j` in Schicht `r`
`w`_i,j^(r-1)		Gewichtung der Verbindung zwischen Neuron `i` in Schicht `r`-1 und Neuron `j` in Schicht `r`
`x`_j		Eingabewert für Neuron `j` in Schicht 0
`y`_j		Zielwert für den Ausgabewert von Neuron `j` in der Ausgabeschicht `n`-1
`f`_j		Fehlerwert für Neuron `j` in der Ausgabeschicht `n`-1
`g`		Gesamtfehler der Ausgabeschicht

Formeln

Der Eingabewert e_j⁽⁰⁾ eines Neurons in Schicht 0 ist gleich dem Eingabewert x_j:

e_j⁽⁰⁾ = x_j

Der Eingabewert e_j^(r) eines Neurons j in Schicht r > 0 ergibt sich als gewichtete Summe aller Ausgabewerte der Neuronen der vorherigen Schicht r-1:

e_j^(r) = Summe _{k=0, ..., m^(r-1)-1} s_k^(r-1) · w_k,j^(r-1)

Der Ausgabewert s_j^(r) eines Neurons j in Schicht r ergibt sich durch Anwendung der Schwellenwertfunktion σ auf den Eingabewert e_j^(r):

s_j^(r) = σ(e_j^(r))

Der Fehlerwert f_j für Neuron j in der Ausgabeschicht n-1 ist die quadratische Abweichung zwischen Ausgabewert s_j^(n-1) und Zielwert y_j:

f_j = 1/2·(s_j^(n-1) – y_j)²

Der Gesamtfehler g der Ausgabeschicht ist gleich der Summe aller Einzelfehler f_j

g = Summe _{j = 0, ..., m^(n-1)} f_j

Vektorschreibweise

Die Werte in den einzelnen Schichten lassen sich als Vektoren schreiben. In Vektorschreibweise lassen sich die jeweiligen Berechnungen sehr viel übersichtlicher darstellen. So ist beispielsweise der Ausgabevektor S^(r) einer Schicht r gleich

S^(r) = s₀^(r), ..., s_m^(r)-1^(r)

Er wird als Zeilenvektor bzw. als 1×m^(r)-Matrix aufgefasst.

Berechnungen in Vektorschreibweise lassen sich mithilfe der Python-Bibliothek numpy direkt in Programme überführen.

`E`^(r)		Eingabevektor in Schicht `r`
`S`^(r)		Ausgabevektor in Schicht `r`
`W`^(r-1)		die `m`^(r-1)×`m`^(r)-Matrix der Gewichtungen zwischen Schicht `r`-1 und Schicht `r`
`X`		Eingabevektor in Schicht 0
`Y`		Zielvektor für die Ausgabeschicht `n`-1
`F`		Fehlervektor in der Ausgabeschicht `n`-1

Zum Trainieren des neuronalen Netzes werden nacheinander unterschiedliche Eingabevektoren X in das neuronale Netz eingegeben und per Vorwärtspropagation jeweils die Aktivierungspotenziale der folgenden Schichten berechnet. Es wird beobachtet, wie gut sich das entsprechende Aktivierungspotenzial der Ausgabeschicht dem jeweils zugehörigen Zielvektor Y annähert.

Die Vorwärtspropagation ist nichts anderes als die Berechnung des Ausgabevektors S^(n-1) aus einem Eingabevektor X.

Vorwärtspropagation

Eingabe:

Neuronales Netz mit n Schichten, Eingabevektor X

Methode:

setze E⁽⁰⁾ = X

setze S⁽⁰⁾ = σ(E⁽⁰⁾)

für r = 1 bis n-1

setze E^(r) = S^(r-1) · W^(r-1)

setze S^(r) = σ(E^(r))

Hierbei ergibt sich der jeweils nächste Eingabevektor E^(r) einer Schicht r des neuronalen Netzes durch Matrixmultiplikation zwischen der 1×m^(r-1)-Matrix S^(r-1) und der m^(r-1)×m^(r)-Matrix W^(r-1). Das Ergebnis ist die 1×m^(r)-Matrix E^(r).

Die Funktion σ wird komponentenweise auf den jeweiligen Eingabevektor E^(r) angewandt.

Programm für die Vorwärtspropagation

Die entsprechende Funktion für die Vorwärtspropagation lautet in der Programmiersprache Python wie folgt. Zuvor wird die Python-Bibliothek numpy eingebunden.

import numpy as np

# Vorwärtspropagation eines Eingabevektors X
# durch ein neuronales Netz mit n Schichten
def propagate(x):
    e[0]=np.array(x).reshape(1,m[0])     # 1 x m[0]-Matrix
    s[0]=sigma(e[0])
    for r in range(1, n):
        e[r]=np.matmul(s[r-1], w[r-1])
        s[r]=sigma(e[r])

Die Funktion σ lässt sich in Python folgendermaßen implementieren:

def sigma(x):
return 1.0/(1+np.exp(-x))

Damit das neuronale Netz lernt, wird in der Trainingsphase nach jeder Vorwärtspropagation eines Eingabevektors der Ausgabevektor mit den bekannten Zielwerten verglichen und daraus eine Anpassung der Gewichtungen berechnet.

Im Anschluss an die Trainingsphase, wenn das neuronale Netz gut gelernt hat, kann es Eingabevektoren mit unbekannten Zielwerten verarbeiten.

Es geht darum, die Abweichung zwischen den Aktivierungspotenzialen der Ausgabeschicht und den Zielwerten auszuwerten und anschließend die Gewichtungen des neuronalen Netzes so anzupassen, dass ein Lerneffekt eintritt. Dieser Vorgang wird als Backpropagation (etwa Zurückverbreiten, Rückspeisung) bezeichnet.

Im Folgenden wird ein neuronales Netz mit n = 3 Schichten betrachtet, mit einer Eingabeschicht 0, einer inneren Schicht 1 und einer Ausgabeschicht 2. Damit wird die Indizierung mit den oberen Indizes anschaulicher. Die Verallgemeinerung auf ein neuronales Netz mit mehreren inneren Schichten ist zum Schluss angegeben.

Wenn das neuronale Netz während der Lernphase noch nicht die richtigen Ausgabewerte liefert, müssen die Gewichtungen angepasst werden. Dies geschieht in Abhängigkeit von den Fehlern f_j⁽²⁾, die an den Neuronen der Ausgabeschicht 2 auftreten.

Zunächst werden die Gewichtungen w_i,j⁽¹⁾ zwischen Schicht 1 und Schicht 2 angepasst. Die Gewichtungen w_k,i⁽⁰⁾ zwischen Schicht 0 und Schicht 1 werden später angepasst.

Ziel ist es, die Fehlerfunktion g abhängig von den einzelnen Gewichtungen zu minimieren. Hierzu wird die Methode des Gradientenabstiegs verwendet. Gesucht ist der Gradient, also die Steigung der Fehlerfunktion g in Abhängigkeit von der Gewichtung w_i,j⁽¹⁾, mit dem Ziel, die Gewichtung in Richtung des Gradienten anzupassen. Die Steigung wird durch die partielle Ableitung von g nach w_i,j⁽¹⁾ berechnet.

Da g abhängig ist von f_j⁽²⁾, dieses wiederum von s_j^(r) und dieses wiederum von e_j^(r), wird die Ableitung mithilfe der Kettenregel durchgeführt. Die Ableitung der Funktion σ(x) ist

σ'(x) = σ(x) · (1 – σ(x))

Dies wird bei der Anwendung der Kettenregel benutzt; die Herleitung ist weiter unten angegeben.

Es folgt die Berechnung der partiellen Ableitung des Gesamtfehlers g nach einer Gewichtung w_i,j⁽²⁾.

Die Formeln mit den partiellen Ableitungen erschließen sich nicht beim schnellen Überfliegen – tatsächlich ist es aber nicht schwierig, sich Schritt für Schritt hindurchzuarbeiten.

∂g

∂w_i,j⁽¹⁾

∂g

∂f_j⁽²⁾

∂s_j⁽²⁾

∂e_j⁽²⁾

∂w_i,j⁽¹⁾

Für die einzelnen Ableitungen in der Kette gilt:

∂g

∂f_j⁽²⁾

∂

∂s_j^(r)

_{t = 0, ..., m⁽²⁾-1} f_t(²⁾ 1

∂f_j⁽²⁾

∂s_j⁽²⁾

∂

∂s_j⁽²⁾

1/2·(s_j⁽²⁾ – y_j)² s_j⁽²⁾ – y_j

∂s_j⁽²⁾

∂e_j⁽²⁾

∂

∂e_j⁽²⁾

σ(e_j⁽²⁾) σ(e_j⁽²⁾) · (1 – σ(e_j⁽²⁾))s_j⁽²⁾ · (1 – s_j⁽²⁾)

∂e_j⁽²⁾

∂w_i,j⁽¹⁾

∂

∂w_i,j⁽¹⁾

_{t = 0, ..., m⁽¹⁾-1} s_t⁽¹⁾ · w_t,j⁽¹⁾s_i⁽¹⁾

Insgesamt gilt also für die Ableitung

∂g

∂w_i,j⁽²⁾

= 1 · (s_j⁽²⁾ – y_j) · s_j⁽²⁾ · (1 – s_j⁽²⁾) · s_i⁽¹⁾

Wenn also die Fehlerwerte f_j⁽²⁾ der Schicht 2 bekannt sind, so lassen sich die Gewichte w_i,j⁽¹⁾ anpassen. Die Anpassung wird durchgeführt, indem der Gradient mit einem kleinen Faktor α multipliziert wird. Der Faktor α ist die Lernrate.

Δw_i,j⁽¹⁾ = α ·

∂g

∂w_i,j⁽¹⁾

= α · (s_j⁽²⁾ – y_j) · s_j⁽²⁾ · (1 – s_j⁽²⁾) · s_i⁽¹⁾

Vektorschreibweise

In Vektorschreibweise ergibt sich die Anpassung dieser Gewichtungen wie folgt:

ΔW = S⁽¹⁾^T · (α · (S⁽²⁾ – Y) ⊙ S⁽²⁾ ⊙ (1 – S⁽²⁾)

Die m⁽¹⁾×m⁽²⁾-Matrix der Gewichtungsänderungen ergibt sich durch Matrixmultiplikation der m⁽¹⁾×1-Matrix S⁽¹⁾^T (der transponierten 1×m⁽¹⁾-Matrix S⁽¹⁾) und einem Ausdruck, der eine 1×m⁽²⁾-Matrix darstellt. Dieser Ausdruck enthält eine Multiplikation zwischen dem Skalar α und Vektoren, die komponentenweise miteinander multipliziert werden. Die komponentenweise Multiplikation von Vektoren wird hier mit dem Zeichen ⊙ notiert. Der Vektor 1 – S⁽²⁾ ergibt sich, indem S⁽²⁾ komponentenweise von einem Vektor, der aus lauter 1'en besteht, subtrahiert wird.

Gegeben ist ein neuronales Netz mit drei Schichten 0, 1, 2. Wie hängt der Fehler f_j⁽²⁾ eines Neurons j in Schicht 2 von einer Gewichtung w_k,i(0) von Neuron k in Schicht 0 zu Neuron i in Schicht 1 ab? Die Berechnung erfolgt ganz ähnlich wie die bei der Anpassung der Gewichtungen zwischen Schicht 1 und Schicht 2, ist aber etwas umfangreicher.

f_j⁽²⁾ hängt von dem Aktivierungspotenzial s_j⁽²⁾ ab
s_j⁽²⁾ hängt von der Eingabe e_j⁽²⁾ ab
e_j⁽²⁾ hängt von dem Aktivierungspotenzial s_i⁽¹⁾ ab
s_i⁽¹⁾ hängt von der Eingabe e_i⁽¹⁾ ab
e_i⁽¹⁾ hängt vom Gewicht w_k,i⁽⁰⁾ ab

Somit ergibt sich für die partielle Ableitung von f_j⁽²⁾ nach w_k,i⁽⁰⁾:

∂f_j⁽²⁾

∂w_k,i⁽⁰⁾

∂f_j⁽²⁾

∂s_j⁽²⁾

∂e_j⁽²⁾

∂s_i⁽¹⁾

∂e_i⁽¹⁾

∂w_k,i⁽⁰⁾

Für die einzelnen Ableitungen in der Kette gilt:

∂f_j⁽²⁾

∂s_j⁽²⁾

∂

∂s_j⁽²⁾

1/2·(s_j⁽²⁾ – y_j)² s_j⁽²⁾ – y_j

∂s_j⁽²⁾

∂e_j⁽²⁾

∂

∂e_j⁽²⁾

σ(e_j⁽²⁾) σ(e_j⁽²⁾)·(1 – σ(e_j⁽²⁾))s_j⁽²⁾ · (1 – s_j⁽²⁾)

∂e_j⁽²⁾

∂s_i⁽¹⁾

∂

∂s_i⁽¹⁾

_t s_t⁽¹⁾· w_t,j⁽¹⁾w_i,j⁽¹⁾

∂s_i⁽¹⁾

∂e_i⁽¹⁾

∂

∂e_i⁽¹⁾

σ(e_i⁽¹⁾) σ(e_i⁽¹⁾)·(1 – σ(e_i⁽¹⁾))s_i⁽¹⁾ · (1 – s_i⁽¹⁾)

∂e_i⁽¹⁾

∂w_k,i⁽⁰⁾

∂

∂w_k,i⁽⁰⁾

_t s_t⁽⁰⁾ · w_t,i⁽⁰⁾s_k⁽⁰⁾

Insgesamt gilt also für die Ableitung

∂f_j⁽²⁾

∂w_k,i⁽⁰⁾

= (s_j⁽²⁾ – y) · s_j⁽²⁾ · (1 – s_j⁽²⁾) · w_i,j⁽¹⁾ · s_i⁽¹⁾ · (1 – s_i⁽¹⁾) · s_k⁽⁰⁾

Um das Gewicht w_k,i⁽⁰⁾ in Richtung des Gradienten so anzupassen, dass sich f_j⁽²⁾ verringert, wird

Δ w_k,i⁽⁰⁾ = α ·

∂f_j⁽²⁾

∂w_k,i⁽⁰⁾

gebildet; hierbei ist α die Lernrate.

Nun beeinflusst w_k,i⁽⁰⁾ aber alle f_j⁽²⁾ mit j = 0, ..., m⁽²⁾. Dies bedeutet, dass die Gewichtsänderungen für alle j berechnet und aufsummiert werden müssen, um den Gesamtfehler g zu verringern.

∂g

∂w_k,i⁽⁰⁾

_{j = 0, ..., m⁽²⁾-1} (s_j⁽²⁾ – y) · s_j⁽²⁾ · (1 – s_j⁽²⁾) · w_i,j⁽¹⁾ · s_i⁽¹⁾ · (1 – s_i⁽¹⁾) · s_k⁽⁰⁾

Etwas umgestellt lautet die Formel

∂g

∂w_k,i⁽⁰⁾

= s_k⁽⁰⁾ · s_i⁽¹⁾ · (1 – s_i⁽¹⁾) · Summe

_{j = 0, ..., m⁽²⁾-1} w_i,j⁽¹⁾ · (s_j⁽²⁾ – y) · s_j⁽²⁾ · (1 – s_j⁽²⁾)

In Vektorschreibweise ergibt sich für alle w_k,i⁽⁰⁾

Δ W⁽⁰⁾ = S^{(0)^T} · (S⁽¹⁾ ⊙ (1 – S⁽¹⁾)) · W⁽¹⁾ · (α · (S⁽²⁾ – Y) ⊙ S⁽²⁾ ⊙ (1 – S⁽²⁾))

Hierbei steht das Zeichen ⊙ wieder für die komponentenweise Multiplikation von Zeilenvektoren gleicher Länge. Das normale Multiplikationszeichen · steht hier für die Matrixmultiplikation, wobei ein Zeilenvektor der Länge m wieder als 1×m-Matrix aufgefasst wird.

In dieser ziemlich komplizierten Formel kommt ein Teil vor, der bereits bei der Anpassung der Gewichte zwischen Schicht 1 und Schicht 2 berechnet worden ist. Dies wird im Backpropagation-Algorithmus ausgenutzt, hier allgemein angegeben für ein neuronales Netz mit n Schichten:

Backpropagation

Eingabe:

Neuronales Netz mit n Schichten, Eingabevektor X, Zielvektor Y, Lernrate α

Methode:

setze r = n-1

setze F^(r) = S^(r) – Y

setze H^(r) = F^(r) ⊙ S^(r) ⊙ (1 – S^(r))

für r = n-2 abwärts bis 1 wiederhole

setze F^(r) = H^(r+1) · W^(r)^T

setze H^(r) = F^(r) ⊙ S^(r) ⊙ (1 – S^(r))

für r = n-1 abwärts bis 1 wiederhole

setze W^(r-1) = S^(r-1)^T · α · H^(r)

Die Implementierung in der Programmiersprache Python lautet wie folgt.

def backpropagate(y):
    y=np.array(y).reshape(1, m[n-1])  # 1 x m[n-1]-Matrix
    r=n-1
    f[r]=s[r] - y
    h[r]=f[r]*s[r]*(1-s[r])
    # Fehler zurückpropagieren
    for r in range(n-2, 0, -1):
        f[r]=np.matmul(h[r+1], w[r].T)
        h[r]=f[r]*s[r]*(1-s[r])
    # Gewichte anpassen
    for r in range(n-1, 0, -1):
        w[r-1] -= np.matmul(s[r-1].T, alpha*h[r])

Die folgende Funktion training erzeugt mithilfe einer Funktion randomInput verschiedenen Paare (X, Y) von Eingabevektoren X und zugehörigen Zielvektoren Y. Der Eingabevektor wird mit propagate per Vorwärtspropagation im neuronalen Netz verarbeitet. Die Funktion backpropagate vergleicht den errechneten Ausgabevektor mit dem Zielvektor Y und speist den Fehler per Backpropagation zurück in das neuronale Netz, um die Gewichtungen anzupassen. Das Training wird k-mal durchgeführt (zum Beispiel k = 50.000).

def training(k):
    for _ in range(k):
        x, y=randomInput()
        propagate(x)
        backpropagate(y)

Anstatt wie hier zufällig erzeugte Daten zu verwenden, wird normalerweise ein Datensatz mit realen Trainingsdaten verwendet, so etwa bei der Erkennung von handgeschriebenen Ziffern.

Es gilt mit zweimaligem Anwenden der Kettenregel, hier ausführlich Schritt für Schritt durchgeführt:

σ(x)' = Klammer auf

1 + e^-x

' = (1 + e^-x)^-1 '(-1) · (1 + e^-x)^-2 · (1 + e^-x)'(-1) · (1 + e^-x)^-2 · e^-x '(-1) · (1 + e^-x)^-2 · e^-x · (-x)'(-1) · (1 + e^-x)^-2 · e^-x · (-1) =

e^-x

(1 + e^-x)²

e^-x

(1 + e^-x)²

–

(1 + e^-x)²

1 + e^-x

(1 + e^-x)²

–

1 + e^-x

–

1 + e^-x

2σ(x) – (σ(x))²σ(x) · (1 – σ(x))

[RHW 86] D.E. Rumelhart, G.E. Hinton, R.J. Williams: Learning representations by back-propagating errors. Nature, Vol. 323, 533-536 (1986)

Weiter mit: [Handgeschriebene Ziffern erkennen] oder [up]

H.W. Lang mail@hwlang.de Impressum Datenschutz
Created: 17.11.2020 Updated: 19.08.2024
Diese Webseiten sind während meiner Lehrtätigkeit an der Hochschule Flensburg entstanden

Datenanalyse

Neuronales Netz

Vorwärtspropagation

Schwellenwertfunktion σ

Bezeichnungsweisen

Bezeichnungen

Formeln

Vektorschreibweise

Trainieren des neuronalen Netzes

Programm für die Vorwärtspropagation

Anpassung der Gewichtungen zwischen Schicht 1 und Schicht 2

Vektorschreibweise

Anpassung der Gewichtungen zwischen Schicht 0 und Schicht 1

Implementierung der Trainingsphase

Anhang: Ableitung der Funktion σ

Literatur

Neuronales Netz

Schwellen­wertfunktion σ

Bezeich­nungen

Formeln

Vektor­schreibweise

Programm für die Vorwärts­propagation

Vektor­schreibweise

Schwellenwertfunktion σ

Bezeichnungen

Vektorschreibweise

Programm für die Vorwärtspropagation

Vektorschreibweise