3.5. Lernalgorithmen für Neuronale Netze

Konnektionistische Wissensverarbeitung
Vorlesung an der Technischen Universität Chemnitz
Sommersemester 2006
Prof. Dr. Werner Dilger
Konnektionistische Wissensverarbeitung
Seite 2
Inhalt
1.
Einleitung.................................................................................................................................................................... 4
2.
Schwellenwertlogik .................................................................................................................................................... 4
2.1.
Netze von Funktionen ......................................................................................................................................... 4
2.2.
Synthese Boolescher Funktionen ........................................................................................................................ 6
2.3.
Gewichtete Netze ................................................................................................................................................ 8
2.4.
Rekurrente Netze ................................................................................................................................................ 9
3.
Das Perzeptron .......................................................................................................................................................... 11
3.1.
Perzeptrone und Parallelverarbeitung ............................................................................................................... 11
3.2.
Implementierung logischer Funktionen ............................................................................................................ 12
3.3.
Linear separierbare Funktionen ........................................................................................................................ 14
3.4.
Anwendungen von Perzeptronen ...................................................................................................................... 16
3.5.
Lernalgorithmen für Neuronale Netze .............................................................................................................. 19
3.6.
Ein Perzeptron-Lernalgorithmus ....................................................................................................................... 22
4.
Unüberwachtes Lernen und Clustering-Algorithmen ............................................................................................... 27
4.1.
Kompetitives Lernen......................................................................................................................................... 27
4.2.
Konvergenzuntersuchung ................................................................................................................................. 29
4.3.
Hauptkomponentenanalyse ............................................................................................................................... 32
4.4.
Anwendungen ................................................................................................................................................... 35
5.
Mehrschichtige Netze ............................................................................................................................................... 36
5.1.
Struktur und geometrische Visualisierung ........................................................................................................ 36
5.2.
Gebiete im Eingabe- und Gewichtsraum .......................................................................................................... 38
5.3.
Gebiete für zweischichtige Netze ..................................................................................................................... 41
6.
Der Backpropagation-Algorithmus ........................................................................................................................... 43
6.1.
Lernen als Gradientenabstieg ............................................................................................................................ 43
6.2.
Allgemeine zyklenfreie Netze ........................................................................................................................... 45
6.3.
Geschichtete Netze ........................................................................................................................................... 49
6.4.
Rekurrente Netze .............................................................................................................................................. 55
7.
Assoziative Netze ..................................................................................................................................................... 59
7.1.
Assoziative Mustererkennung ........................................................................................................................... 59
7.2.
Assoziatives Lernen .......................................................................................................................................... 61
7.3.
Das Kapazitätsproblem ..................................................................................................................................... 66
7.4.
Die Pseudoinverse............................................................................................................................................. 66
8.
Das Hopfield-Modell ................................................................................................................................................ 70
8.1. Synchrone und asynchrone Netze ..................................................................................................................... 70
8.2.
Definition der Hopfield-Netze .......................................................................................................................... 72
8.3.
Konvergenz bei Hopfield-Netzen ..................................................................................................................... 75
8.4.
Äquivalenz des Hopfield- und Perzeptron-Lernens .......................................................................................... 77
8.5.
Parallele Kombinatorik ..................................................................................................................................... 78
9.
Kohonen-Netze ......................................................................................................................................................... 83
9.1.
Selbstorganisation ............................................................................................................................................. 83
9.2.
Kohonens Modell .............................................................................................................................................. 83
9.3.
Konvergenzanalyse ........................................................................................................................................... 86
9.4.
Anwendungen ................................................................................................................................................... 90
10. Modulare Neuronale Netze ....................................................................................................................................... 92
10.1.
Konstruktive Algorithmen für modulare Netze ............................................................................................ 92
10.2.
Hybride Netze ............................................................................................................................................... 94
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 3
Literatur
R. Brause: Neuronale Netze. Eine Einführung in die Neuroinformatik.2 Teubner-Verlag, Stuttgart,
1995.
T. Kohonen: Self-organizing maps.2 Springer, Berlin, 1997.
R. Rojas: Neural Networks. A systematic introduction. Springer, Berlin, 1996.
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
1.
Seite 4
Einleitung
Programm der Vorlesung: In Kapitel 2 werden die Grundlagen der Neuronalen Netze, die einfachen
funktionalen Elemente, behandelt. Sie zeichnen sich dadurch aus, dass sie aus den Eingaben berechnete Werte mit einem Schwellenwert vergleichen und davon abhängig eine Ausgabe erzeugen oder
nicht. In Kapitel 3 und 4 wird die einfachste Form der Netze, das Perzeptron, zunächst nach Aufbau
und Funktionsweise dargestellt und anschließend betrachtet, wie solche Netze lernen können. Diese
Form des Lernens heißt „überwachtes Lernen“. Es gibt aber auch eine andere Form, das unüberwachte Lernen, dieses wird in Kapitel 5 eingeführt. Erweitert man die Perzeptrone, dann bedeutet
dies vor allem, dass man eine komplexere Struktur definiert, und zwar indem man mehrere so
genannte Schichten einführt. Welche Probleme dies grundsätzlich mit sich bringt, wird in Kapitel 6
dargestellt. Das Lernen in solchen mehrschichtigen Netzen erfolgt mit Hilfe des BackpropagationAlgorithmus, der in Kapitel 7 eingeführt wird. In den weiteren Kapiteln werden die Hopfield-Netze,
die Kohonen-Netze und die wachsenden Zellstrukturen behandelt.
2.
Schwellenwertlogik
2.1. Netze von Funktionen
2.1.1. Zyklenfreie und rekurrente Netze
Ein Neuronales Netz wird zunächst als Black box betrachtet, es wird nur erwartet, dass aus
bestimmten Eingaben bestimmte Ausgaben entstehen, die Parameter werden nicht alle spezifiziert,
vielmehr sollen sie sich durch einen Lernprozess ergeben. Aus dieser Sicht stellt sich ein Neuronales Netz wie in Abbildung 2.1 dar. Das Netz realisiert eine Abbildung der Form
F : n  m
x1
x2
xn
..
.
F
..
.
y1
y2
ym
Abbildung 2.1
Die Funktion F wird realisiert durch eine Menge primitiver Funktionen, die in einem Netz
miteinander verknüpft sind. Bei der Berechnung von F findet ein Informationsfluss durch das Netz
statt. Ein Teil der Knoten berechnet Werte, die an andere Knoten als Eingaben weitergegeben
werden. Enthält das Netz keine Zyklen, dann ist das Ergebnis der Berechnung wohldefiniert. Dabei
benötigt man keine Synchronisation zwischen den Knoten, man muss aber voraussetzen, dass die
Berechnung in den einzelnen Knoten ohne Zeitverzögerung vonstatten geht.
Im Fall von rekurrenten Netzen spielt die Synchronisation zwischen den Knoten eine Rolle, denn
hier kann die Ausgabe wieder als Eingabe an den selben Knoten oder an Knoten, die bereits in die
Berechnung einbezogen waren, zurückgeführt werden. In diesem Fall liegt eine rekursive Berechnung ohne explizites Haltekriterium vor. Deshalb muss festgelegt werden, was das Netz berechnen
soll, den Fixpunkt der rekursiven Auswertung oder ein Zwischenergebnis. Dazu wird angenommen,
dass jede Berechnung durch einen Knoten eine bestimmte Zeit benötigt, z.B. eine Zeiteinheit. Die
zum Zeitpunkt t eingehenden Argumente liefern ein Ergebnis zum Zeitpunkt t+1. Die Berechnung
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 5
kann nach einer bestimmten Zahl von Schritten gestoppt werden und die dann vorliegende Ausgabe
als Ergebnis der Berechnung genommen werden.
2.1.2. Die Recheneinheiten
Die Knoten eines Neuronalen Netzes heißen Rechenelemente oder Einheiten. Die Kanten des
Netzes sind gerichtet, so dass die Information in einer vorgegebenen Richtung propagiert wird. Die
Zahl der in eine Einheit eingehenden Kanten oder Eingaben sei nach oben unbegrenzt.
Die eigentliche Berechnung durch eine Einheit soll allerdings möglichst durch eine einstellige
Funktion ausgeführt werden. Deshalb müssen die n Eingaben durch eine integrierende Funktion zu
einem Wert zusammengefasst werden. Dazu werden die Einheiten in zwei Funktionsteile unterteilt:


Die Integrationsfunktion g fasst die n Argumente zu einem einzigen Wert zusammen.
Die Ausgabe- oder Aktivierungsfunktion f erzeugt aus dem Wert von g eine Ausgabe.
Abbildung 2.2 zeigt die allgemeine Struktur einer Einheit. Als Integrationsfunktion wird meistens
die Addition verwendet.
x1
x2
.
..
g f
f(g(x1, x2, ..., xn))
xn
Abbildung 2.2
Die ursprüngliche Form Neuronaler Netze, wie sie von McCulloch und Pitts definiert wurde, war
sogar noch einfacher, denn sie arbeiten nur mit binären Werten. Die Kanten können einen von zwei
verschiedenen Typen haben, nämlich exzitatorisch und inhibitorisch. Jede McCulloch-Pitts-Einheit
besitzt einen Schwellenwert . Abbildung 2.3 zeigt die Standarddarstellung einer McCulloch-PittsEinheit und der beiden Kantentypen. Die Einheit besteht aus einer weißen und einer schwarzen
Hälfte. Eingehende Kanten kommen an der weißen Hälfte an, ausgehende Kanten verlassen die
Einheit an der schwarzen Hälfte. Sie können sich in eine beliebige Anzahl von Kanten verzweigen.
x1
exzitatorische Kante
x2
.
.
.

inhibitorische Kante
xn
McCulloch-Pitt-Einheit
Abbildung 2.3
Die Eingabe in eine McCulloch-Pitts-Einheit wird nach folgender Regel verarbeitet:
1. Die Einheit bekomme die Eingaben x1, x2, ..., xn über n exzitatorische Kanten und die Eingaben
y1, y2, ..., ym über m inhibitorische Kanten.
2. Ist m  1und hat mindestens eine der Eingaben y1, y2, ..., ym den Wert 1, dann wird die Einheit
inaktiv gesetzt (inhibited) und das Ergebnis der Berechnung ist 0.
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 6
3. Andernfalls wird die Summe x = x1 + x2 + ... + xn gebildet. Ist n = 0, dann ist x = 0. x wird mit
dem Schwellenwert  verglichen. Ist x  , dann ist das Ergebnis der Berechnung 1 (die Einheit
feuert), ist x < , dann ist das Ergebnis der Berechnung 0.
2.2. Synthese Boolescher Funktionen
2.2.1. Konjunktion, Disjunktion, Negation
Einfache logische Funktionen können durch einzelne McCulloch-Pitts-Einheiten realisiert werden.
Die Ausgabewerte 1 bzw. 0 werden mit den Wahrheitswerten wahr bzw. falsch identifiziert. Die
Funktionen AND und OR werden durch die Einheiten von Abbildung 2.4 realisiert.
AND
OR
x1
x1
2
1
x2
x2
Abbildung 2.4
Eine monotone logische Funktion f mit n Argumenten ist eine Funktion mit der Eigenschaft, dass an
zwei Punkten x = (x1, ..., xn) und y = (y1, ..., yn) gilt: Sind die in y enthaltenen Einsen eine Teilmenge
der in x enthaltenen Einsen, dann ist f(x)  f(y).
Satz 2.1: McCulloch-Pitts-Einheiten ohne inhibitorische Kanten können nur monotone logische
Funktionen realisieren.
2.2.2. Geometrische Interpretation
Logische Funktionen können auf einfache Weise geometrisch veranschaulicht werden. Bis zu
dreistellige Funktionen lassen sich auch graphisch darstellen. Die Eingabewerte bilden Punkte im
Raum (2, 4 oder 8), genauer gesagt die Eckpunkte einer Strecke, eines Quadrats oder eines Würfels,
jeweils mit der Seitenlänge 1. An jedem der Eckpunkte wird einer der Funktionswerte 0 oder 1
notiert. Abbildung 2.5 zeigt dies für eine dreistellige Funktion.
x2
0
1
1
0
0
1
x1
0
1
x3
Abbildung 2.5
Allgemein bekommt man bei einer Funktion mit n Argumenten einen Würfel mit 2n Ecken. In
n
diesem sind 2 2 Zuordnungen von Werten zu den Ecken möglich. McCulloch-Pitts-Einheiten unterteilen den Eingaberaum in zwei Halbräume. Bei einer gegebenen Eingabe wie (x1, x2, x3) und dem
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 7
Schwellenwert  wird die Bedingung x1 + x2 + x3   abgeprüft. Sie ist erfüllt für alle Punkte auf
einer Seite der Ebene x1 + x2 + x3 = , einschließlich der Punkte in der Ebene, und nicht erfüllt für
die Punkte auf der anderen Seite der Ebene, ausschließlich der Punkte der Ebene. Abbildung 2.6
zeigt den Fall der dreistelligen OR-Funktion mit  = 1.
x2
1
1
1
1
1
0
x1
1
x 1 + x2 + x3 = 1
x3
1
Abbildung 2.6
Abbildung 2.g zeigt die graphische Darstellung der Majoritätsfunktion. Der Eingaberaum wird
hier durch die Ebene x1 + x2 + x3 = 2 unterteilt. Sie ist parallel zu der Ebene der OR-Funktion.
Alle unterteilenden Ebenen bei McCulloch-Pitts-Einheiten sind parallel zueinander. Nicht parallele Trennebenen können nur mittels gewichteter Kanten erzeugt werden.
x2
x 1 + x2 + x3 = 2
1
1
1
1
1
0
x1
1
x3
x 1 + x2 + x3 = 1
1
Abbildung 2.g
2.2.3. Konstruktive Synthese
Beliebige logische Funktionen können mit McCulloch-Pitts-Einheiten realisiert werden. Um dies
systematisch zu tun, geht man von der Darstellung einer logischen Funktion in Tabellenform aus.
Die Tabelle hat n+1 Spalten. In jeder Zeile steht eine Eingabe mit n Werten und ein Ausgabewert.
Die Idee der Konstruktion eines McCulloch-Pitts-Netzes ist, für jede Zeile eine Einheit vorzusehen
und das Ergebnis der Zeilen geeignet zusammen zu fassen. Die McCulloch-Pitts-Einheiten werden
dabei als binäre Decoder benutzt.
Die Konstruktionsvorschrift für ein McCulloch-Pitts-Netz zur Realisierung einer n-stelligen logischen Funktion ist folgende. Die Funktion sei in Tabellenform gegeben. Jede Zeile der Tabelle
ergibt eine McCulloch-Pitts-Einheit als Decoder der Eingabe. Einsen im Eingabevektor werden als
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 8
exzitatorische, Nullen als inhibitorische Kanten der jeweiligen Einheit realisiert. Der Schwellenwert
der jeweiligen Einheit ist gleich der Summe der positiven Eingaben oder exzitatorischen Kanten.
Diese Einheiten bilden die decodierende Schicht des Netzes. Die zweite Schicht des Netzes besteht
aus einer Einheit, die die Ausgaben der decodierenden Schicht disjunktiv verknüpft.
Satz 2.2: Jede logische Funktion F: {0, 1}n  {0, 1} kann durch ein McCulloch-Pitts-Netz mit
zwei Schichten berechnet werden.
Die Konstruktion von McCulloch-Pitts-Netzen nach obiger Vorschrift kann so abgeändert werden,
dass man jede decodierende Einheit durch ein kleines Netz ersetzt, in dem nur noch die Standardeinheiten AND, OR und NOT verwendet werden. Anstelle der inibitorischen Kanten werden NOTEinheiten verwendet und alle Eingaben durch AND zusammengefasst. Abbildung 2.7 illustriert diese
Umformung. Diese Betrachtung führt zu der Aussage von Satz 2.3.
x1
x2
x3
1
x1
0
x2
0
3
x3
Abbildung 2.7
Satz 2.3: Jede logische Funktion kann durch ein McCulloch-Pitts-Netz berechnet werden, das nur
aus AND-, OR- und NOT-Einheiten zusammengesetzt ist.
2.3. Gewichtete Netze
2.3.1. Gewichtete und ungewichtete Netze
McCulloch-Pitts-Netze sind ungewichtet, deshalb stellt sich die Frage, ob gewichtete Netze allgemeiner sind als ungewichtete. Ein einfaches Beispiel zeigt aber bereits, dass die beiden Typen von
Netzen äquivalent sind. In Abbildung 2.8(a) ist eine gewichtete Einheit dargestellt, die die Funktion
0.2 x1  0.4 x2  0.3x3  0.7
berechnet. Diese ist aber äquivalent zu der Funktion
2 x1  4 x2  3x3  7
und diese wird durch die McCulloch-Pitts-Einheit von Abbildung 2.8(b) berechnet.
x1
0.4
x2
x1
0.2
0.7
x2
7
0.3
x3
x3
(a)
(b)
Abbildung 2.8
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 9
2.3.2. Absolute und relative Inhibition
Die in McCulloch-Pitts-Netzen benutzte Inhibition nennt man auch absolute Inhibition. Man kann
auch eine relative Inhibition definieren. Sie entspricht Kanten mit negativen Gewichten, deren
Wirkung die Verminderung des Schwellenwerts einer Einheit ist.
Satz 2.4: McCulloch-Pitts-Netze sind äquivalent zu Netzen mit relativer Inhibition.
2.4. Rekurrente Netze
2.4.1. Netze mit gespeichertem Zustand
McCulloch-Pitts-Einheiten können in rekurrenten Netzen verwendet werden, wenn man einen
zeitlichen Faktor in die Berechnung einbezieht. Dazu wird angenommen, dass die Berechnung der
Aktivierung einer Einheit eine Zeiteinheit benötigt. Kommt die Eingabe zum Zeitpunkt t an, dann
liegt das Ergebnis zum Zeitpunkt t + 1 vor.
Abbildung 2.9 zeigt ein einfaches rekurrentes Netz. Es erzeugt für jedes Eingabebit dasselbe Ausgabebit, außer bei zwei aufeinanderfolgenden Einsen, für diese gibt es die Folge 01 aus. Zum
Beispiel wird die Folge 00110110 in die Folge 00100100 umgewandelt.
1
Eingabe
2
Ausgabe
Abbildung 2.9
2.4.2. Endliche Automaten
Das Netz von Abbildung 2.9 ist ein Beispiel für einen endlichen Automaten. Ein endlicher Automat
kann verschiedene Zustände annehmen und sie in Abhängigkeit von der Eingabe wechseln. Er kann
ferner eine Ausgabe erzeugen in Abhängigkeit von seinem Zustand. Bei dem Automaten von Abbildung 2.9 stellen die verschiedenen Kombinationen von Signalen, die durch das Netz zirkulieren
können, die Zustände dar.
Satz 2.5: Jeder endliche Automat kann durch ein McCulloch-Pitts-Netz simuliert werden.
2.4.3. Eine erste Klassifikation Neuronaler Netze
Man kann Neuronale Netze nach drei Kriterien in verschiedene Klassen unterteilen.
1. Gewichtete und ungewichtete Netze. Die beiden Typen von Netzen sind äquivalent. Der Hauptunterschied zwischen beiden liegt in der Art, wie sie lernen. In ungewichteten Netzen können
nur die Schwellenwerte und die Verbindungen zwischen den Einheiten angepasst werden. In
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 10
gewichteten Netzen wird die Topologie üblicherweise beim Lernen nicht verändert, sondern es
werden nur die Gewichte angepasst.
2. Synchrone und asynchrone Netze. In synchronen Netzen wird die Ausgabe der Einheiten ohne
Zeitverzögerung berechnet. Das ist möglich, wenn das Netz keine Schleifen enthält. In manchen
Netzen sind die Einheiten in Schichten angeordnet und die Aktivität der Einheiten wird schichtweise nacheinander berechnet, aber in jeder Schicht simultan. In asynchronen Netzen wird die
Aktivität einer Einheit unabhängig von den anderen Einheiten und an verschiedenen stochastisch ausgewählten Zeitpunkten berechnet. Solche Netze können Schleifen enthalten, die
keine Probleme machen.
3. Netze mit und ohne gespeicherte Zustände. Die Zustände werden in den einzelnen Einheiten
gespeichert. Die Berechnung der Ausgabe hängt dann auch vom gespeicherten Zustand ab, nicht
nur von der Eingabe. Der Zustand kann bei jeder Berechnung geändert werden. Ist die Zahl der
Zustände und der Eingaben endlich, dann liegt ein endlicher Automat vor. Da jeder endliche
Automat durch ein Netz von Einheiten ohne gespeicherte Zustände simuliert werden kann,
können speicherfähige Einheiten dieser Art durch ein McCulloch-Pitts-Netz ersetzt werden. Das
heißt, dass Netze mit speicherfähigen Einheiten äquivalent zu Netzen ohne speicherfähige
Einheiten sind. Die Daten werden bei ihnen im Netz selbst und seinen Rekursionsmustern
gespeichert.
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
3.
3.1.
Seite 11
Das Perzeptron
Perzeptrone und Parallelverarbeitung
3.1.1. Perzeptrone als gewichtete Netze
Der Psychologe Frank Rosenblatt schlug 1958 das Perzeptron als Berechnungsmodell vor. Das
wesentlich Neue gegenüber den McCulloch-Pitts-Netzen waren die numerischen Gewichte und ein
spezielles Verknüpfungsmuster. Im ursprünglichen Modell von Rosenblatt sind die Einheiten
Schwellenwertelemente und die Verknüpfung ist stochastisch bestimmt. Lernen erfolgt durch
Anpassen der Gewichte nach einem bestimmten Algorithmus. Das Modell wurde in den sechziger
Jahren verfeinert und vervollständigt und seine Berechnungsfähigkeit wurde von Minsky und
Papert analysiert. Minsky und Papert benutzten dazu eine Variante des Modells. Diese wird im Folgenden als Perzeptron bezeichnet, Rosenblatts ursprüngliches Modell als klassisches Perzeptron.
Das klassische Perzeptron ist ein Netz für bestimmte Mustererkennungsprobleme. Abbildung 3.1
zeigt ein solches Netz.
Projektionsebene
Assoziationsebene
Responseebene
Retina
feste Verbindungen
zufällige Verbindungen
Abbildung 3.1
Die Retina ist eine Oberfläche, auf die die Eingabe projiziert wird. Sie überträgt binäre Werte auf
die Projektionsebene, eine Schicht von Recheneinheiten. Die Verbindungen von der Retina zur
Projektionsebene sind fest und nicht adaptierbar. Die Verbindungen zwischen der zweiten und
dritten Schicht und zwischen der dritten und vierten Schicht sind stochastisch ausgewählt um das
Modell biologisch plausibel zu machen. Das Netz soll so trainiert werden, dass bestimmte Eingabemuster bestimmte Reaktionen an der Responseebene erzeugen. Dies geschieht durch Modifikation
der Gewichte. Die Einheiten eines klassischen Perzeptrons funktionieren formal betrachtet genau so
wie McCulloch-Pitts-Einheiten.
Im Perzeptron von Minsky und Papert gibt es ebenfalls eine Retina, die aus Pixeln mit binären
Werten besteht. Einige Pixel sind mit logischen Elementen verknüpft, Prädikate genannt, die aus
der Eingabe einzelne Bits berechnen können. Die Zahl der Pixel, die mit einem Prädikat verknüpft
sein können, und ihre Entfernung untereinander sind beschränkt. Die Prädikate können beliebig
komplexe Recheneinheiten sein. Die Prädikate übertragen ihre binären Werte über gewichtete
Kanten an ein Schwellenwertelement. Dieses entscheidet in einem Mustererkennungsproblem.
Abbildung 3.2 zeigt ein Perzeptron nach dem Modell von Minsky und Papert.
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 12
P1
w1
P2
w2
P3
P4
w3

w4
Abbildung 3.2
Ein Perzeptron besteht im Allgemeinen aus n Prädikaten P1, P2, ..., Pn und den entsprechenden
n
Gewichten w1, w2, ..., wn. Es feuert nur, wenn i 1 wi Pi   , wobei  der Schwellenwert der Einheit an der Ausgabe ist.
3.1.2. Die Grenzen der Berechnungsfähigkeit des Perzeptrons
Minsky und Papert unterschieden bezüglich der Anzahl der rezeptiven Felder und ihrer Verbindung
mit den Prädikaten zwischen drei Typen von Perzeptronen:



Durchmesserbeschränkte Perzeptrone: Das rezeptive Feld jedes Prädikats hat beschränkten
Durchmesser.
Perzeptrone beschränkter Ordnung: Jedes rezeptive Feld kann höchstens eine bestimmte maximale Anzahl von Punkten enthalten.
Stochastische Perzeptrone: Jedes rezeptive Feld besteht aus einer Anzahl zufällig gewählter
Punkte.
Satz 3.1: Kein durchmesserbeschränktes Perzeptron kann entscheiden, ob eine geometrische Figur
zusammenhängend ist oder nicht.
3.2.
Implementierung logischer Funktionen
3.2.1. Geometrische Interpretation
Definition 3.1: Ein einfaches Perzeptron ist eine Recheneinheit mit einem Schwellenwert , der bei
Eingabe von n reellen Werten x1, x2, ..., xn über Kanten mit Gewichten w1, w2, ..., wn eine 1 ausgibt,
n
wenn die Ungleichung i 1 wi xi   gilt, und sonst eine 0.
Die Herkunft der Eingaben spielt keine Rolle, sie kann von anderen Perzeptronen oder von einer
anderen Klasse von Rechenelementen stammen. Die geometrische Interpretation der Verarbeitung
durch ein Perzeptron ist die selbe wie bei den McCulloch-Pitts-Einheiten. Ein Perzeptron unterteilt
den Eingaberaum in zwei Halbräume. Für Punkte im einen Halbraum ist das Ergebnis der Berechnung 0, für Punkte im anderen Halbraum ist es 1. Abbildung 3.3 zeigt als Beispiel die geometrische
Interpretation der Berechnung durch ein Perzeptron mit zwei Eingaben und den Kantengewichten
0.9 und 2.0. Dieses Perzeptron prüft die Bedingung
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 13
0.9 x1  2 x2  1
x2
0.9x1 + 2x2  1
x1
0.9x1 + 2x2 < 1
Abbildung 3.3
In vielen Fällen ist es günstig, Perzeptrone mit dem Schwellenwert 0 zu betrachten. Die geometrische Interpretation eines solchen Elements ist eine lineare Unterteilung des Eingaberaums durch
eine Gerade, die durch den Nullpunkt geht. Man kann ein Perzeptron mit Schwellenwert  einfach
in eines mit Schwellenwert 0 umwandeln, indem man ein zusätzliche Eingabe mit Gewicht 
vorsieht. Der Wert der neuen Eingabe ist konstant 1. Das extra Gewicht des Perzeptrons heißt sein
Bias. Abbildung 3.4 illustriert dies.
x1
x1
w1
.
.
.
wn
w1
.
.
.
wn

xn
0

xn
1
Abbildung 3.4
Die Verwendung so modifizierter Perzeptrone ist günstig für Lernalgorithmen. Der Eingabevektor
(x1, x2, ..., xn) muss um eine 1 erweitert werden, und der neue Eingabevektor (x1, x2, ..., xn, 1) heißt
erweiterter Eingabevektor. Der erweiterte Gewichtsvektor ist (w1, w2, ..., wn, ).
3.2.2. Das XOR-Problem
Betrachtet man Funktionen von zwei Variablen, so gibt es insgesamt 16 verschiedene logische
Funktionen dieser Art, vgl. Tabelle 3.1.
x1
0
0
1
1
x2
0
1
0
1
f0
0
0
0
0
f1
1
0
0
0
Technische Universität Chemnitz
f2
0
1
0
0
f3
1
1
0
0
f4
0
0
1
0
f5
1
0
1
0
f6
0
1
1
0
f7
1
1
1
0
f8
0
0
0
1
f9
1
0
0
1
f10 f11 f12 f13 f14 f15
0 1 0 1 0 1
1 1 0 0 1 1
0 0 1 1 1 1
1 1 1 1 1 1
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 14
Tabelle 3.1
Perzeptron-berechenbar sind diejenigen Funktionen, bei denen die Punkte mit dem Funktionswert 0
durch eine Gerade von den Punkten mit dem Funktionswert 1 getrennt werden können. Solche
Funktionen sind z.B. die AND- und die OR-Funktion, wie Abbildung 3.5 zeigt.
OR
AND
1
1
0
1
0
1
0
0
Abbildung 3.5
Betrachtet man die Funktionen der Tabelle 3.1, dann sieht man, dass zwei davon nicht in dieser
Weise berechnet werden können, weil bei ihnen die 0- und 1-wertigen Punkte nicht durch eine Linie
getrennt werden können. Es sind die Funktion XOR (f6) und die Identitätsfunktion (f9). Eine
analytische Betrachtung bestätigt dies.
Seien w1 und w2 die Gewichte eine Perzeptrons mit zwei Eingaben und  der Schwellenwert. Falls
das Perzeptron die XOR-Funktion berechnet, müssen die folgenden vier Ungleichungen erfüllt sein:
x1 = 0
x1 = 1
x1 = 0
x1 = 1
x2 = 0
x2 = 0
x2 = 1
x2 = 1
w1x1 + w2x2 = 0
w1x1 + w2x2 = w1
w1x1 + w2x2 = w2
w1x1 + w2x2 = w1 + w2

0<

w1  

w2  
 w1 + w2 < 
Nach der ersten Ungleichung ist  positiv, also sind es auch w1 und w2 nach der zweiten und dritten
Ungleichung und jedes von beiden ist mindestens so groß wie . Daher kann die Ungleichung w1 +
w2 <  nicht gelten. Aus diesem Widerspruch ergibt sich, dass kein Perzeptron die XOR-Funktion
berechnen kann.
3.3. Linear separierbare Funktionen
3.3.1. Lineare Separierbarkeit
Definition 3.2: Zwei Mengen von Punkten A und B in einem n-dimensionalen Raum heißen linear
separierbar, wenn es n+1 reelle Zahlen w1, w2, ..., wn+1 gibt, so dass jeder Punkt (x1, x2, ..., xn)  A
n
die Ungleichung i 1 wi xi  wn1 erfüllt und jeder Punkt (x1, x2, ..., xn)  B die Ungleichung

n
i 1
wi xi  wn1 .
Eine interessante Frage ist, wie viele linear separierbare Funktionen von n Variablen es gibt. In
Tabelle 3.2 sind die Werte für n = 2, 3, 4 aufgelistet.
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 15
n
Anzahl logischer Funktionen
linear separierbare Funktionen
2
16
14
3
256
104
4
65536
1882
Tabelle 3.2
3.3.2. Die Dualität von Eingaberaum und Gewichtsraum
Um die geeigneten Gewichte für ein Perzeptron zu bestimmen, muss man Suche im Gewichtsraum
betreiben. Dieser Raum ist aber sehr groß, denn bei m Gewichten ist es der gesamte Raum m. Bei
einem Perzeptron mit n Eingaben bedeutet die Suche nach einer linearen Separierung die Suche
nach n+1 freien Parametern, nämlich n Gewichte und das Bias. Diese n+1 Parameter repräsentieren
einen Punkt im (n+1)-dimensionalen Gewichtsraum. Sobald man einen Punkt im Gewichtsraum
herausgreift, wählt man eine bestimmte Kombination der Gewichte und bestimmt damit eine lineare
Trennung des Eingaberaums. Das heißt, jeder Punkt im (n+1)-dimensionalen Gewichtsraum ist zu
einer Ebene im (n+1)-dimensionalen erweiterten Eingaberaum assoziiert. Abbildung 3.6 illustriert
dies für den dreidimensionalen Fall.
x2
w2
x1
w1
w3 = 
x3
Abbildung 3.6
Eine ähnliche Relation gilt auch in umgekehrter Richtung. Wenn man einen Punkt (x1, x2, x3) im
positiven Halbraum ansiedeln möchte, dann muss man dafür die Gewichte w1, w2, w3 geeignet
bestimmen. Dazu muss die Ungleichung
w1 x1  w2 x2  w3 x3  0
gelten. Diese Ungleichung definiert aber eine lineare Trennung im Gewichtsraum, d.h. der Punkt
(x1, x2, x3) definiert eine Schnittebene im Gewichtsraum. Punkte im einen Raum werden auf Hyperebenen im anderen Raum abgebildet und umgekehrt. Diese Komplementarität heißt Dualität.
3.3.3. Die Fehlerfunktion im Gewichtsraum
Angenommen die Menge A von Eingabevektoren in einem n-dimensionalen Raum soll von der
Menge B von Eingabevektoren so getrennt werden, dass das Perzeptron die binäre Funktion fw
berechnet mit fw(x) = 1 für x  A und fw(x) = 0 für x  B. Die Funktion fw hängt von der Menge w
der Gewichte und dem Schwellenwert ab. Die Fehlerfunktion gibt die Zahl der falschen Klassifikationen an, die man mit dem Gewichtsvektor w erhält. Sie kann definiert werden durch
E ( w)   (1  f w ( x))  f w ( x)
xA
Technische Universität Chemnitz
xB
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 16
Diese Funktion ist über dem gesamten Gewichtsraum definiert und das Ziel eines Lernalgorithmus
ist sie zu minimieren. Da E(w) mindestens 0 ist, versucht man das globale Minimum mit E(w) = 0
zu bestimmen. Dazu beginnt man mit einem zufällig gewählten Gewichtsvektor w und sucht dann
im Gewichtsraum nach einer besseren Alternative, wobei man bei jedem Schritt versucht, E(w) zu
verringern.
3.3.4. Allgemeine Entscheidungskurven
Funktionen, die zur Trennung von Gebieten des Eingaberaums benutzt werden, heißen Entscheidungskurven. Häufig gebrauchte Entscheidungskurven sind z.B. Polynome. In der statistischen
Mustererkennung geht man davon aus, dass die zu erkennenden Muster in Clustern des Eingaberaums gruppiert sind. Mittels einer Kombination von Entscheidungskurven kann man versuchen die
Cluster zu trennen. Eine andere Möglichkeit ist mehrere Perzeptrone zu kombinieren um ein
konvexes Gebiet des Eingaberaums zu separieren. Die Aufgabe eines Neuronalen Netzes ist es
allgemein, durch einen Lernalgorithmus die freien Parameter (hauptsächlich die Gewichte) so zu
bestimmen, dass die relevanten Gebiete getrennt werden.
3.4. Anwendungen von Perzeptronen
3.4.1. Kantenerkennung
Es sei folgende Anordnung gegeben: Die Figuren, die untersucht werden sollen, werden auf einem
Bildschirm dargestellt und jedes Pixel ist mit einem Perzeptron verbunden, das außerdem Eingaben
von den unmittelbaren Nachbarn des Pixels bekommt. Ein rezeptives Feld dieser Art, genannt eine
Moore-Nachbarschaft, ist in Abbildung 3.7 dargestellt. Die Zahlen stellen die Gewichte der
Verbindungen zu dem Perzeptron dar.
-1
-1
-1
-1
8
-1
-1
-1
-1
Abbildung 3.7
Die Festlegung des Mittelpunkts auf einen hohen Wert und der übrigen Punkte auf einen negativen
Wert nennt man einen Konvolutionsoperator. Er wird zum Zentrieren auf jedes einzelne Pixel des
Bildes benutzt um für jedes Pixel einen bestimmten Ausgabewert zu erzeugen. Abbildung 3.8
illustriert die Verbindung zwischen einer Pixelumgebung, also einem rezeptiven Feld, und einem
Perzeptron.
0.5
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 17
Abbildung 3.8
Bei jedem Muster auf dem Bildschirm wird für jedes Perzeptron die gewichtete Eingabe mit dem
Schwellenwert 0.5 verglichen. Sind alle Punkte in der Umgebung des Pixels im Zentrum des Rezeptorfeldes hell, dann ist die Eingabe 0 und damit das Perzeptron inaktiv. Sind alle Punkte in der
Umgebung dunkel, dann ist die Summe der Eingaben ebenfalls 0. Im Fall von Abbildung 3.8 ist die
Eingabe 5, damit gehört der Mittelpunkt des Rezeptorfeldes zu einer Kante.
3.4.2. Pyramidale Netze und das Neocognitron
Fukushima und seine Kollegen haben zum Zweck der Mustererkennung für verschobene oder
rotierte oder unvollständige Muster das Cognitron und das Neocognitron entwickelt. Damit sollte
auch der menschliche Erkennungsweg simuliert werden. Die Idee beim Neocognitron ist den Inhalt
des Bildschirms auf andere Bildschirme zu übertragen und dabei durch Verstärken einiger Merkmale zu transformieren. Dieser Schritt wird mehrere Male wiederholt bis eine endgültige Entscheidung getroffen wird. Die Auflösung und die Zahl der Bildschirme kann von einem Übergang zum
anderen verändert werden, das Ziel ist auf jeden Fall die Repräsentation zu reduzieren um auf der
letzten Stufe eine Entscheidung nur auf der Basis einiger weniger Punkte zu treffen.
Bei einem Neocognitron wird das Bild von einer Ebene zur nächsten umgeformt um spezifische
Merkmale zu finden. In Abbildung 3.9 ist die allgemeine Vorgehensweise eines Neocognitrons
dargestellt. Der Eingabebildschirm wird transformiert wobei für jedes Pixel entschieden wird, ob es
hell bzw. dunkel bleiben soll. Dazu werden die vorgegebenen Muster der einzelnen Transformationen benutzt. Diese werden im Bild identifiziert indem jedes Pixel und seine Nachbarn betrachtet
wird. Die Konvolutionsoperatoren haben entsprechend den Mustern das Gewicht 1, alle anderen
Gewichte sind 0.
Transformation
Konvolutionsoperatoren
Muster
1
1
1
1
1
1
1
1
1
Abbildung 3.9
Im Neocognitron sind nach dem Eingabebildschirm vier Paare von Ebenen nacheinander angeordnet. Zwischen den Ebenen eines Paares werden bisher entstandene Muster wieder zusammengefasst. Von der zweiten Ebene eines Paares zur ersten Ebene des nächsten Paares wird die oben
beschriebene Transformationstechnik mit Aufteilung der bisher entstandenen Muster durchgeführt.
Außerdem wird dabei die Helligkeit der dunklen Punkte graduell abgeschwächt, während sie beim
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 18
Zusammenfassen der Muster wieder verstärkt wird, wenn dasselbe Pixel in zwei verschiedenen
Mustern gefärbt ist.
3.4.3. Die Silikonretina
Die Silikonretina wurde von der Gruppe von Carver Mead am Caltech entwickelt. Sie ist in der
Lage einige Fähigkeiten der menschlichen Retina zu simulieren. Das Fernziel dieser Arbeiten ist,
die Retina bei Sehgeschädigten durch eine künstliche zu ersetzen.
Die ersten drei Schichten der Retina, die Photorezeptoren, die horizontalen Zellen und die bipolaren
Zellen, wurden simuliert. Ein Ausschnitt ist in Abbildung 3.10 dargestellt. Die horizontalen Zellen
sind durch ein Gitter von Widerständen simuliert. Jeder Photorezeptor (in Abbildung 3.10 als
dunkle Punkte dargestellt) ist mit jedem seiner sechs Nachbarn verbunden und erzeugt eine Potentialdifferenz, die proportional zum Logarithmus der gemessenen Helligkeit ist. Das Gitter der
Widerstände erreicht einen elektrischen Gleichgewichtszustand, wenn sich eine durchschnittliche
Potentialdifferenz herausgebildet hat. Die Neuronen der Silikonretina feuern nur, wenn die Differenz zwischen dem Durchschnitt und ihrem eigenen Potential einen bestimmten Schwellenwert
erreicht.
Abbildung 3.10
Das durchschnittliche Potential S von n Potentialen Si wird berechnet, indem man jedes Potential Si
als proportional zum Logarithmus der gemessenen Lichtintensität Hi festlegt, d.h.
S
1 n
1 n
S

log H i
 i n
n i 1
i 1
Dieser Ausdruck kann in den folgenden umgeformt werden:
S  1n log( H 1 H 2  H n )  log( H 1 H 2  H n )1 / n
Das durchschnittliche Potential ist demnach der Logarithmus des geometrischen Mittels der Lichtintensitäten. Eine Einheit feuert nur, wenn die gemessene Intensität Hi minus der durchschnittlichen
Intensität über einem Schwellenwert  liegt, d.h. wenn
log( H i )  log( H 1 H 2  H n )1 / n  
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 19
und dieser Ausdruck ist äquivalent zu
log
Hi

( H 1 H 2  H n )1 / n
3.5. Lernalgorithmen für Neuronale Netze
Ein Lernalgorithmus ist ein adaptives Verfahren, durch das ein Netz von Recheneinheiten sich
selbst organisiert um das gewünschte Verhalten zu realisieren. In einigen Lernalgorithmen wird dies
dadurch erreicht, dass dem Netz einige Beispiele des gewünschten Eingabe/Ausgabeverhaltens vorgelegt werden. Ein Korrekturschritt wird so lange wiederholt, bis das Netz gelernt hat die
gewünschte Ausgabe zu erzeugen. Der Lernalgorithmus ist also eine Schleife aus Eingabe von
Beispielen und Korrektur der Netzparameter.
3.5.1. Klassen von Lernalgorithmen
Lernalgorithmen können in die beiden Klassen der überwachten und der nicht überwachten Verfahren eingeteilt werden. Beim überwachten Lernen wird eine Menge von Eingabevektoren in das Netz
eingegeben. Dann wird die vom Netz erzeugte Ausgabe betrachtet und ihre Abweichung von der
gewünschten Ausgabe gemessen. Dann werden die Gewichte entsprechend der Größe der Abweichung auf eine für den Lernalgorithmus spezifische Art angepasst. Diese Methode wird auch
Lernen mit Lehrer genannt, weil ein Steuerungsprozess die korrekte Antwort auf eine Menge ausgewählter Eingabevektoren kennt.
Das unüberwachte Lernen setzt keinen Lehrer voraus, d.h. für die Eingabevektoren ist die genaue
Ausgabe nicht bekannt. Ein typisches Beispiel für eine Aufgabe, die durch unüberwachtes Lernen
gelöst werden kann, ist eine Clustering-Aufgabe. Eine Punktmenge ist in Cluster zu unterteilen.
Dafür eignet sich ein Neuronales Netz, das ebenso viele Ausgänge hat wie Cluster zu erwarten sind
oder bestimmt werden sollen, z.B. n Stück. Jede der n Einheiten am Ausgang entspricht einem
Cluster. Von ihnen soll bei einer Eingabe immer nur eine feuern, die anderen nicht. Das Netz muss
sich selber organisieren um die Cluster zu bestimmen.
Das überwachte Lernen kann noch weiter unterteilt werden in das Reinforcement Learning und das
Lernen mit Fehlerkorrektur. Das Reinforcement Learning wird benutzt, wenn man bei der Ausgabe
nur feststellen kann, ob es das gewünschte Ergebnis ist oder nicht, man aber kein Maß für die
Abweichung hat. Entsprechend dieser Information werden die Gewichte aktualisiert, d.h. zur
Korrektur der Gewichte können nur die Eingabevektoren benutzt werden. Beim Lernen mit Fehlerkorrektur bestimmt die Größe des Fehlers zusammen mit dem Eingabevektor die Größe der Korrektur an den Gewichten. In vielen Fällen versucht man, den Fehler in einem Schritt zu korrigieren.
Der Perzeptron-Lernalgorithmus ist ein Verfahren des überwachten Lernens mit Reinforcement.
Einige Varianten des Algorithmus benutzen überwachtes Lernen mit Fehlerkorrektur. Abbildung
3.10 stellt die Klassifikation der Lernverfahren dar.
Lernen mit Fehlerkorrektur
Überwachtes Lernen
Reinforcement Learning
Lernen
Unüberwachtes Lernen
Abbildung 3.10
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 20
3.5.2. Vektornotation
Die folgenden Notationen und Begriffe werden verwendet. Die Eingabe x = (x1, x2, ..., xn) in das
Perzeptron heißt Eingabevektor. Sind w1, w2, ..., wn die reellwertigen Gewichte des Perzeptrons und
 der Schwellenwert, dann ist w = (w1, w2, ..., wn) der Gewichtsvektor und we = (w1, w2, ..., wn, wn+1)
mit wn+1 =  der erweiterte Gewichtsvektor und xe = (x1, x2, ..., xn, 1) der erweiterte Eingabevektor
des Perzeptrons. Die Schwellenwertberechnung eines Perzeptrons wird durch ein Skalarprodukt
beschrieben. Sie ist
w  x   bzw. w e  x e  0
Ist aus dem Kontext klar, ob die normalen oder erweiterten Vektoren gemeint sind, wird der Index e
weggelassen.
3.5.3. Absolute lineare Trennbarkeit
Definition 3.3: Zwei Mengen A und B von Punkten in einem n-dimensionalen Raum heißen absolut
linear trennbar, wenn es n+1 reelle Zahlen w1, w2, ..., wn, wn+1 gibt, so dass jeder Punkt (x1, x2, ...,
n
xn)  A die Bedingung i 1 wi xi  wn1 und jeder Punkt (x1, x2, ..., xn)  B die Bedingung

n
i 1
wi xi  wn1 erfüllt.
Der folgende Satz formuliert, dass aus der linearen Trennbarkeit die absolute lineare Trennbarkeit
für endliche Punktmengen folgt. Eine Konsequenz aus diesem Satz ist, dass wenn ein Perzeptron
mit Schwellenwert 0 zwei endliche Mengen von Eingabevektoren linear trennen kann, nur eine
kleine Anpassung seiner Gewichte erforderlich ist um die absolute lineare Trennung zu erreichen.
Satz 3.2: Zwei endliche Mengen A und B von Punkten in einem n-dimensionalen Raum, die linear
trennbar sind, sind auch absolut linear trennbar.
3.5.4. Die Fehleroberfläche und das Suchverfahren
Definition 3.4: Der offene (geschlossene) positive Halbraum, der mit dem n-dimensionalen
Gewichtsvektor w assoziiert ist, ist die Menge aller Punkte x  n, für die wx > 0 (wx  0) gilt.
Der offene (geschlossene) negative Halbraum, der mit w assoziiert ist, ist die Menge aller Punkte x
 n, für die wx < 0 (wx  0) gilt.
Seien P und N zwei endliche Punktmengen in n, die linear getrennt werden sollen. Es soll ein
Gewichtsvektor w so bestimmt werden, dass die Punkte von P in seinem assoziierten positiven
Halbraum liegen und die Punkte von N in seinem negativen Halbraum. Der Fehler eines Perzeptrons mit Gewichtsvektor w ist die Zahl der falsch klassifizierten Punkte, er ist also eine Funktion
E(w). Der Lernalgorithmus muss diese Fehlerfunktion minimieren. Eine mögliche Strategie ist
einen Greedy-Algorithmus zu verwenden, der den Fehler für einen gegebenen Gewichtsvektor
berechnet, dann nach einer Richtung im Gewichtsraum sucht, in die er sich bewegen soll, und den
Gewichtsvektor durch Wahl neuer Gewichte in der gewählten Suchrichtung aktualisiert. Diese
Strategie kann man visualisieren, indem man ihre Wirkung im Gewichtsraum betrachtet.
Als Beispiel wird das Perzeptron von Abbildung 3.11 betrachtet. Es hat den konstanten Schwellenwert 1. Die Gewichte w1 und w2 sollen so bestimmt werden, dass das Perzeptron sich wie ein
binäres AND-Gatter verhält.
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 21
x1
w1
1
w2
x2
Abbildung 3.11
Die Fehlerfunktion kann für alle Wertekombinationen der zwei Gewichtsvariablen grafisch dargestellt werden. In Abbildung 3.12 ist dies für den Wertebereich zwischen –0.5 und 1.5 durchgeführt.
Abbildung 3.12
Die Lösungsregion liegt im Bereich des Dreiecks in der Mitte. Man kann sich dem Bereich von
jedem Punkt aus nähern. Da er das am tiefsten liegende Gebiet des Geländes ist, kann man sich dem
Gefälle folgend dem Lösungsbereich nähern. Abbildung 3.13 zeigt eine Draufsicht auf das Gelände.
Die verschiedenen Regionen der Fehlerfunktion sind durch Zahlen gekennzeichnet.
w2
w0
1
2
0
2
w1
w2
w*
1
1
w1
2
Abbildung 3.13
Das zu lösende Optimierungsproblem kann auch noch als Suche nach einem inneren Punkt im
Lösungsbereich aufgefasst werden. Seien N = {(0, 0), (1, 0), (0, 1)} und P = {(1, 1)} die beiden
Mengen, die absolut getrennt werden sollen. P soll im positiven Halbraum, N im negativen Halbraum liegen. Zur Trennung mit einem Perzeptron benötigt man die drei Gewichte w1, w2 und w3 =
. Die Eingabevektoren werden um x3 = 1 erweitert und die folgenden Ungleichungen (mit Skalarprodukt) müssen gelten:
(0, 0, 1)(w1, w2, w3) < 0
(1, 0, 1)(w1, w2, w3) < 0
Technische Universität Chemnitz
(3.3)
(3.4)
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 22
(0, 1, 1)(w1, w2, w3) < 0
(1, 1, 1)(w1, w2, w3) > 0
(3.5)
(3.6)
 0 0  1
 0

  w1   
  1 0  1    0 
 0  1  1  w2    0 

   
 1 1 1   w3   0 


 
(3.7)
In Matrixschreibweise:
oder kurz
Aw > 0
wobei A die obige Matrix und w der Gewichtsvektor ist. Die Ungleichung (3.7) beschreibt die
inneren Punkte eines konvexen Polytops. Die Seiten des Polytops sind durch Ebenen begrenzt, die
durch die Ungleichungen (3.3) – (3.6) definiert sind. Jeder innere Punkt des Polytops ist eine
Lösung des Lernproblems.
3.6. Ein Perzeptron-Lernalgorithmus
Der Lernalgorithmus für das Perzeptron benötigt eine Trainingsmenge, die aus den beiden Mengen
P und N aus dem n-dimensionalen erweiterten Eingaberaum besteht. Gesucht ist ein Vektor w, der
die beiden Mengen so absolut linear trennt, dass P im positiven Halbraum und N im negativen
Halbraum liegt.
Algorithmus 3.1 Perzeptron-Lernen
Start:
Der Gewichtsvektor w0 wird beliebig gesetzt
t := 0
Test:
Ein Vektor x  P  N wird zufällig gewählt
if x  P and wtx > 0 goto Test
if x  P and wtx  0 goto Add
if x  N and wtx < 0 goto Test
if x  N and wtx  0 goto Subtract
Add:
wt := wt + x
t := t + 1
goto Test
Subtract:
wt := wt  x
t := t + 1
goto Test
3.6.1. Geometrische Veranschaulichung
Das Perzeptron-Lernen kann auf zwei alternative Arten veranschaulicht werden, je nachdem, ob
man die Ausgangsvektoren oder die erweiterten Vektoren verwendet. Seien die beiden Punktmengen P, N  2 gegeben. Abbildung 3.14 zeigt die Veranschaulichung mit den Ausgangsvektoren.
Hier wird eine Trennung durch eine Gerade gesucht (angedeutet durch Graufärbung). Abbildung
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 23
3.15 zeigt die Veranschaulichung mit den erweiterten Vektoren. Die Trennung ist hier durch eine
Ebene durch den Nullpunkt gegeben, definiert durch die Gleichung w1x1 + w2x2 + w3 = 0.
Vektoren in P
p2
Gewichtsvektor
p1
n1
n2
Vektoren in N
Abbildung 3.14
Gewichtsvektor
p2
p1
n1
n2
Abbildung 3.15
Der Perzeptron-Lernalgorithmus startet mit einem zufällig gewählten Gewichtsvektor w0. Wird ein
Vektor x  P gefunden mit wx < 0, dann bedeutet das geometrisch, dass der Winkel zwischen den
beiden Vektoren größer als 90° ist. Der Gewichtsvektor muss in Richtung von x gedreht werden um
diesen Vektor in den positiven Halbraum zu bringen. Dies kann durch Addition von w und x
gemacht werden, wie im obigen Algorithmus. Wird ein Vektor x  N gefunden mit wx > 0, dann
ist der Winkel zwischen den beiden Vektoren kleiner als 90°. Der Gewichtsvektor muss dann von x
weg gedreht werden um diesen Vektor in den negativen Halbraum zu bringen. Dies kann man
erreichen indem man x von w subtrahiert, wie im obigen Algorithmus. Für den Start ist es günstig,
den Durchschnitt der positiven Eingabevektoren minus dem Durchschnitt der negativen Eingabevektoren als Gewichtsvektor zu wählen.
3.6.2. Konvergenz des Algorithmus
Satz 3.3: Wenn die Mengen P und N endlich und linear trennbar sind, dann aktualisiert der Perzeptron-Lernalgorithmus den Gewichtsvektor wt endlich oft. Anders ausgedrückt: Werden die
Vektoren in P und N zyklisch nacheinander getestet, dann wird nach endlich vielen (t) Schritten ein
Gewichtsvektor wt gefunden, der die beiden Mengen trennt.
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 24
3.6.3. Beschleunigung der Konvergenz
Eine Verbesserung des Perzeptron-Lernalgorithmus kann man auf folgende Weise erreichen: Wird
bei Iteration t der Eingabevektor x falsch klassifiziert, dann gilt wtx  0. Der Fehler  kann
definiert werden als  = wtx. Der neue Gewichtsvektor wird wie folgt berechnet:
w t 1  w t 
 
|| x || 2
x
 bezeichnet eine kleine positive reelle Zahl. Die Klassifikation von x kann in einem Schritt
korrigiert werden, weil
w t 1  x  (w t 
 
x)  x
|| x || 2
= wtx + ( + )
=   + ( + )
=>0
Die Zahl  garantiert, dass der neue Gewichtsvektor gerade noch über den Rand der Region mit
dem größeren Fehler gerät.  sollte klein genug gewählt werden um zu vermeiden, dass der Vektor
in eine andere Region gerät, deren Fehler größer als der der jetzigen Region ist. Für x  N wird der
Korrekturschritt ähnlich ausgeführt, aber statt  +  wird    verwendet.
3.6.4. Der Taschenalgorithmus
Algorithmus 3.2 Taschenalgorithmus
Start:
Initialisiere den Gewichtsvektor w zufällig. Definiere ein „gespeichertes“ Gewicht
ws = w. Setze hs, die History von ws, auf 0.
Iteriere:
Aktualisiere w mittels einer Iteration des Perzeptron-Lernalgorithmus. Merke die
Anzahl h der danach erfolgreich getesteten Vektoren. Wenn irgendwann h > hs, dann
ersetze ws durch w und hs durch h. Fahre fort.
Gelegentlich ersetzt der Algorithmus einen guten gespeicherten Gewichtsvektor durch einen
schlechteren, weil nur die Information aus dem letzten Lauf mit den ausgewählten Beispielen
betrachtet wird. Die Wahrscheinlichkeit dafür nimmt aber mit der Zahl der Iterationen ab. Man
kann zeigen, dass bei endlicher Trainingsmenge und rationalen Gewichten und Vektoren der Algorithmus mit Wahrscheinlichkeit 1 gegen die optimale Lösung konvergiert.
3.6.5. Komplexität des Perzeptron-Lernens
Der Perzeptron-Lernalgorithmus ist ein Greedy-Algorithmus. Er wählt eine Suchrichtung im
Gewichtsraum nach der inkorrekten Klassifikation des zuletzt getesteten Vektors aus, also auf
Grund lokaler Information, und benutzt keine globale Information über die Form der Fehlerfunktion. Das kann zu einer exponentiellen Zahl von Aktualisierungen des Gewichtsvektors führen.
Dafür gibt es zwei extreme Typen von Fällen. Beim ersten liegt die Nullfehlerregion im spitzen
Winkel zwischen zwei Geraden, die sich in einem engen Winkel schneiden und der initiale
Gewichtsvektor liegt außerhalb dieser Region. Dies ist in Abbildung 3.16 dargestellt.
Technische Universität Chemnitz
Sommersemester 2006
Konnektionistische Wissensverarbeitung
Seite 25
w2
1
Iterationen
Nullfehlerregion
2
1
w0
w1
Abbildung 3.16
Im zweiten Fall sind zwei Vektoren als zum selben Halbraum gehörend zu klassifizieren, sie sind
aber fast antiparallel zueinander. Abbildung 3.17 illustriert diesen Fall. Der Gewichtsvektor wird in
Richtung des einen Vektors verschoben, wodurch der andere falsch klassifiziert wird. Eine große
Zahl von Iterationen ist erforderlich, bis beide Vektoren richtig klassifiziert werden. Diese Zahl
wird umso größer, je näher der Winkel zwischen den beiden Vektoren bei 180° liegt.
x2
x1
Abbildung 3.17
Technische Universität Chemnitz
Sommersemester 2006