Sie sind auf Seite 1von 21

Perzeptron

Modell von Rosenblatt (1958)

Ziel: Mustererkennung

Minsky und Papert (1969) reduzierten auf das Wesentliche.

P 1 w 1 P w 2 2  w 3 P 3 w 4
P
1
w 1
P
w
2
2
w
3
P
3
w
4
P
4

0/1

P i : 0/1-Prädikate, typischerweise von beschränktem Durchmesser, liefern Information über die abgetasteten Punkte in der

Projektionsfläche (z.B. ob ein bestimmter Lichtreiz vorliegt):

Vereinfachtes Perzeptron-Modell

Von Prädikaten abstrahiert. Keine Einschränkung, woher die Eingabe kommt.

x 1

w 1 x 2 w 2  w y n x n
w 1
x
2
w
2
w
y
n
x
n

y =

1

falls

0 sonst

n

i 1

w x

i

i

 

(Integrationsf. g = gewichtete Summe, Aktivierungsf. f = Schwellenwertf.)

Einfache Beispiele: x 2 1 –1 1.5 x 1  x 2 x 2
Einfache Beispiele:
x
2
1
–1
1.5
x 1  x 2
x
2

x

x

x

x

1 1 1 2 AND 2
1
1
1
2
AND
2
1 1 1 1 OR 2
1
1
1
1
OR
2

Geometrische Interpretation eines Perzeptrons

ähnlich wie bei McCulloch-Pitts-Neuronen ein Perzeptron trennt den Eingaberaum n in 2 Regionen:

x 1 n w 1 {(x 1 , , x n ) :  w
x 1
n
w 1
{(x 1 ,
, x n ) :
 w
i x
 }
i
i  1
n
w n
{(x 1 ,
, x n ) :
 w
< }
y
i x
x n
i
i  1
n
w
x
Trennung findet durch die Hyperebene
i statt
= 
i
i
 1
x
Beispiel:
2
1
x
2
1
–1
1.5
x
x 1  x 2
-1
1
x
2

Lineare Trennbarkeit

Definition: Zwei Mengen A und B in n heißen linear trennbar,

falls w 1 ,

, w n , w n+1 existieren, so dass

n

• (x 1 , , x n )  A   w i x
• (x 1 ,
, x n )  A
 w
i x
i
 w n+1
i  1
n
• (x 1 ,
, x n )  B
 w
i x
i
< w n+1
i  1
x 2
A
x 1
B

Definition: Eine binäre Funktion f : n {0, 1} heißt linear trennbar, falls die Mengen A = f 1 (1) und B = f 1 (0) linear trennbar sind.

Beispiele:

f(x 1 ,x 2 ) = x 1 OR x 2 linear trennbar:

f 1 (1) = {(0,1), (1,0), (1,1)} f 1 (0) = {(0,0)}

f(x 1 ,x 2 ) = x 1 XOR x 2 nicht linear trennbar:

x 2
x 2

x 1

f 1 (1) = {(0,1), (1,0)}, f 1 (0) = {(0,0), (1,1)}

x 2
x 2

x 1

Grenzen eines Perzeptrons:

Beweis:

Aus 0w 1 + 1w 2 w 3 und 1w 1 + 0w 2 w 3 folgt w 1 + w 2 2w 3 .

Aus 0w 1 + 0w 2 < w 3 und 1w 1 + 1w 2 < w 3 folgt w 1 + w 2 < 2w 3 . Widerspruch!

Satz:

Die XOR-Funktion kann von einem Perzeptron allein nicht berechnet werden.

Absolute lineare Trennbarkeit

Definition: Zwei Mengen A und B in n heißen absolut linear

trennbar, falls w 1 ,

, w n , w n+1 existieren, so dass

(x 1 ,

, x n ) A

(x 1 ,

, x n ) B

n

w

i 1

n

w

i 1

i x

i

> w n+1

i x

i

< w n+1

echte Ungleichung in beiden Fällen

Satz: Es seien A und B endliche Mengen in n . Dann gilt:

A und B linear trennbar A und B absolut linear trennbar.

Beweis: Die Richtung ist klar.

(:) Angenommen, A und B sind linear trennbar.

Dann existieren w 1 ,

, w n , w n+1 , so dass

(x 1 ,

, x n ) A

(x 1 ,

, x n ) B

Setze = min{w n+1

n

i 1

n

i 1

n

i 1

w

w

i

i

x

x

w x

i

i

i

i

w n+1

< w n+1

: (x 1 ,

,

x

n

) B}.

existiert (warum?) und > 0.

Definiere w' n+1 := w n+1 /2. Dann ist wegen > 0: w' n+1 < w n+1 und deshalb:

(x 1 ,

, x n ) A

(x 1 ,

, x n ) B

n

i 1

n

i 1

w x

i

w x

i

i

i

w n+1

< w' n+1

n

i 1

w

i

x

i

w n+1

n

i 1

w n+1 > w' n+1

w x

i

i

>

/2

Def. von

< w' n+1 w n+1

Def. von w' n+1

≥ w x i i  >  /2  Def. von  < w '

Perzeptron-Lernaufgabe

Gegeben: Endliche linear trennbare Mengen P und N in n (‘‘positive‘‘ und ‘‘negative‘‘ Muster)

Aufgabe: Finde Gewichtsvektor w = (w 1 ,

, w n ) und Schwellenwert ,

so dass P und N durch das Perzeptron (absolut) linear getrennt werden:

(x 1 ,

x n ) P

x n ) N

,

,

xw T = x 1 w 1 +

+ x n w n 

(x 1 ,

xw T = x 1 w 1 +

+ x n w n <

Vereinfachung: Schwellenwert wird als ein weiteres Gewicht interpretiert.

x

x

w 1 1  w n n
w
1
1
w
n
n
weiteres Gewicht interpretiert. x x w 1 1  w n n x 1 w 1
x 1 w 1 w x n 0 – n 1
x
1
w
1
w
x
n
0
–
n
1

OBdA kann mit Schwellenwert null gearbeitet werden:

Erweiterter Gewichtsvektor : (w 1 ,

Erweiterter Eingabevektor :

(x

1 ,

, w n , )

, x n ,1)

Definition: Sei w ein Vektor in n . Offener positiver Halbraum:

{x n : xw T > 0}

Abgeschlossener positiver Halbraum: {x n : xw T 0}

Analog für (offenen/abgeschlossenen) negativen Halbraum.

Die Perzeptron-Lernaufgabe (mit Schwellenwert 0) besteht darin, einen Gewichtsvektor w zu finden, so dass die Punkte

aus P im positiven Halbraum und

die Punkte aus N im negativen Halbraum liegen.

p 1 w p 2 n 1 n 2 xw T < 0
p
1
w
p 2
n 1
n
2
xw T < 0

xw T > 0

Fehler des Perzeptrons (mit Gewichtsvektor w):

Anzahl der Punkte von P im negativen Halbraum

+

Anzahl der Punkte von N im positiven Halbraum

(= Anzahl der falsch klassifizierten Punkte).

Fehler als Funktion der Gewichtsvektoren w soll

durch Änderung von w minimiert werden.

Fehlerflächen: (hier für die OR-Funktion und festen Schwellenwert 1)

w

1

w

2

Fehler

-1

0

3

0

2

1

Lernen: Wandern im Fehlergebirge bis Tal (Fehler = 0) erreicht.

Problem: Wie wandern?

0 3 0 2 1  Lernen : Wandern im Fehlergebirge bis Tal (Fehler = 0)

Perzeptron-Lernalgorithmus

Eingabe: Endliche linear trennbare Mengen P und N in n .

Ausgabe: Gewichtsvektor w = (w 1 ,

, w n ) , der P und N absolut linear trennt,

wobei P im offenen positiven und N im offenen negativen Halbraum liegen.

(1)

Wähle w = (w 1 ,

,

w n ) mit zufälligen Werten

(2)

repeat

(3)

fehler: = false

/* Fehler des Perzeptrons ? */

(4)

for

jedes x P N

do

(5)

begin

(6)

if

(x P

and

xw T 0) then

(7)

begin fehler:= true, w:= w + x end

(8)

if

(x N

and

xw T 0) then

(9)

begin fehler:= true; w:= w x end

(10)

end

 

(11) until not fehler

Epoche = 1 Durchlauf der for-Schleife

Geometrische Veranschaulichung

Der Winkel zwischen x und w sei . Es ist xw T = ||x||||w||cos .

Deshalb:

x P

xw T > 0

cos > 0

x N

xw T < 0

cos < 0

90 o < < 90 o 90 o < < 270 o

p 1 w p 2 n 1 n 2
p
1
w
p 2
n 1
n
2

Lernen:

Falls x P und || 90 o , so wird w (durch Addition von w und x) in Richtung von x gezogen

(Winkel zwischen x und w wird kleiner).

Falls x N und || 90 o , so wird w (durch Addition von w und x ) in Richtung von x gezogen. (Winkel zwischen x und w wird größer). Hier ist der Winkel zw. x und w.

Geometrische Veranschaulichung

p 1 n 1 w 0 n 2 Anfang (Fehler = 2)
p 1
n 1
w 0
n 2
Anfang (Fehler = 2)
p 1 n 1 w 1 w 0 n 2 x = p 1 falsch
p 1
n 1
w 1
w 0
n 2
x = p 1 falsch erkannt:

w 1 = w 0 + p 1

Geometrische Veranschaulichung

p 1 n 1 w 1 n 2 Fehler = 1
p 1
n 1
w 1
n 2
Fehler = 1
-n 2 p 1 w 2 n 1 w 1 n 2 x = n
-n 2
p 1
w 2
n 1
w 1
n 2
x = n 2 falsch erkannt:

w 2 = w 1 n 2

Geometrische Veranschaulichung

p 1 w 2 n 1 n 2
p 1
w 2
n 1
n 2

Fehler = 0: Alle Punkte sind richtig klassifiziert!

Perzeptron-Konvergenz-Theorem

Wird das Perzeptron irgendwann mit dem Lernen fertig sein?

Satz: Falls P und N linear trennbar sind, dann terminiert der Perzeptron-

Lernalgorithmus mit einem Gewichtsvektor w, der P und N absolut trennt.

Beweis:

Sei w* ein Vektor, der P und N absolut trennt.

Schreibe P' = P {x : x N}.

: = min{w*q T : q P'}. existiert, da P' endlich ist, und > 0, da w* P und N absolut trennt. : = max{||q|| : q P'}. existiert, da P' endlich ist, und > 0, da P und N trennbar sind.

Sei w 0 der Anfangsvektor w in Zeile (1) und w t die t-te Änderung des Gewichtsvektors w (Zeile (7) bzw. (9)).

Angenommen, w t+1 sei berechnet worden. D.h. es gibt ein p P', das bzgl.

w t falsch klassifiziert wurde:

wurde vorgenommen.

pw t T 0, und die Korrektur w t+1 = w t + p

Der Winkel zwischen w* und w t+1 sei . Es ist:

||w*||cos = (w*w t+1 T ) ||w t+1 ||.

Nun gilt:

w*w t+1 T = w*(w t + p) T = w*w t T + w*p T w*w t T + .

Wiederholte Abschätzung liefert:

w*w t+1 T w*w 0 T + (t+1) .

Außerdem:

||w t+1 || 2 = (w t + p)(w t + p) T = ||w t || 2 + 2 pw t T +||p|| 2

||w t || 2 + 2 .

Wiederholte Abschätzung liefert:

||w t+1 || 2 ||w 0 || 2 + (t+1)2 .

Es folgt: ||w*||cos = (w*w t+1 T ) ||w t+1 ||

da

pw t T 0

(w*w 0 T + (t+1) ) (||w 0 || 2 + (t+1)2 ) ½ (t )

Da ||w*||cos ||w*||, kann t also nicht beliebig groß sein: Die Anzahl der

Änderungen von w ist endlich und der Algorithmus terminiert.

, kann t also nicht beliebig groß sein: Die Anzahl der Änderungen von w ist endlich

Komplexitätsbetrachtung

Der Perzeptron-Lernalgorithmus hat im schlechtesten Fall exponentielle Laufzeit.

Die Perzeptron-Lernaufgabe kann als ein lineares Programm formuliert werden.

Simplex-Algorithmus

lösbar in Polynomialzeit mit Khachiyan (1979), aber in der Regel langsamer als der Simplex-Algorithmus. Schneller mit Karmarkar (1984)

Was kann ein Perzeptron im nicht linear trennbaren Fall?

Satz: Gegeben seien Zahlen k, n und Mengen P, N in n . Dann ist das Entscheidungsproblem, ob es ein Perzeptron gibt, das P und N mit höchstens k Fehlern trennt, NP-vollständig.

Beschleunigung: Normierung

Das Problem:

Als falsch erkannte lange Eingabevektoren x verändern den Gewichtsvektor

w übermäßig stark: w + x x.

Als falsch erkannte kurze Vektoren verursachen aber nur geringe Veränderung des Gewichtsvektors: w + x w.

Beispiel: P ={(1, 1), (100, 130)} und N = {(1, 1)}

Abhilfe:

Normierung der Vektoren: x ||x||. Dadurch werden alle Eingabevektoren ‘‘gleichwertig‘‘ sein.

Normierung der Eingabevektoren ändert das Problem nicht: Trennt w die normierten Vektoren, so trennt w auch die ursprünglichen Vektoren.

Das obige Beispiel braucht 8 Epochen (Excel-Test) mit Normierung

(85 Epochen ohne Normierung!)

Perzeptron-Lernalgorithmus mit Delta-Regel

Gewünschte Ausgabe des Perzeptron bei Eingabevektor

x = (x 1 ,

, x n ) sei t {0, 1}.

Also: t = 1, falls x P und t = 0, falls x N.

Tatsächliche Ausgabe des Perzeptron bei Eingabevektor

x = (x 1 ,

, x n ) sei y {0, 1}.

Fehlersignal:

Lernfaktor (Lernrate):

= t y. .

Der Lernfaktor ist eine Konstante zwischen 0 und 1, und gibt

an, wie viel vom Fehler korrigiert werden soll.

Änderung:

Korrektur:

w =   x.

w := w + w (Delta-Regel)

Perzeptron-Lernalgorithmus mit Delta-Regel

Ist x P falsch erkannt, so = t y = 1 0 = 1,

und w wird um x korrigiert: w:= w + w = w + x.

Ist x P richtig erkannt, so = t y = 1 1 = 0, und es wird keine Korrektur für w vorgenommen: w:= w + w = w.

Analog für Eingabevektoren x N: Ist x falsch erkannt,

so = 1 und w wird um x korrigiert:

Sonst wird keine Korrektur vorgenommen.

w:= w x.

Der diskutierte Perzeptron-Algorithmus hat also einen Lernfaktor = 1.