Cascade-Correlations-Verfahren anhand des Xor-Problems

Fakultät Informatik und
Mathematik
Fach: Neuronale Netze
Prof. Jürgen Sauer
Cascade-Correlations-Verfahren
anhand des Xor-Problems
Projektbearbeiter:
Friling Olga
Kerlin Stefan
1

Der Cascade-Correlation-Algorithmus
Der Cascade-Correlation-Algorithmus lässt sich durch zwei Ideen charakterisieren. Die eine
ist die Kaskaden-Architektur, in der verdeckte Neuronen einzeln zu dem Netzwerk
hinzugefügt werden und ihre Eingangsgewichte danach nicht mehr ändern. Die zweite ist der
Lernalgorithmus, der diese verdeckten Neuronen erzeugt und ihre Gewichte bestimmt.
Dieser versucht für jedes hinzugefügte Neuron den Betrag der Korrelation zwischen der
Ausgabe des Neurons und dem restlichen Fehlersignal zu maximieren und auf diese Weise
den Restfehler möglichst stark zu minimieren.
Abb. 1 Die Architektur des Cascade-Correlation Netzwerks
Die Architektur des Cascade-Correlation Netzwerks ist in Abb. 1 dargestellt. Zu Beginn des
Trainings existiert nur die durch die Problemstellung vorgegebene Anzahl von Eingabe- und
Ausgabezellen, jedoch keine verdeckten Neuronen. Jede Eingabezelle ist mit jeder
Ausgabezelle durch eine Verbindung mit trainierbarem Gewicht verbunden (helle Quadrate).
Es existiert auch ein Bias-Neuron, dessen Ausgabe immer +1 ist und das mit allen
Ausgabezellen verbunden ist.
Die Ausgabeneuronen können eine lineare oder eine nichtlineare Aktivierungsfunktion
besitzen. Die meisten Experimente mit Cascade-Correlation wurden bisher mit sigmoiden
Aktivierungsfunktionen wie tangens hyperbolicus f ( x) = tanh( x)
durchgeführt.
Das Lernverfahren fügt nun einzeln verdeckte Neuronen zu dem Netzwerk hinzu. Jedes
neue verdeckte Neuron erhält Eingaben von allen Vorgängern, d.h. von den
Eingabeneuronen und den vorher generierten verdeckten Neuronen. Die Eingabegewichte
dieser Neuronen werden eingefroren, sobald das Neuron dem Netzwerk hinzugefügt wurde.
Nur die Gewichte der Verbindungen zu den Ausgabeneuronen werden weiterhin trainiert. Auf
diese Art und Weise stellt jedes Neuron der verdeckten Schicht eine Ebene für sich dar.
Der Lernalgorithmus beginnt zuerst ohne verdeckte Neuronen. Die direkten Verbindungen
zwischen Eingabeebene und Ausgabeebene werden über die gesamte Trainingsmenge so
gut wie möglich trainiert, beispielsweise durch die Delta-Regel oder Quickprop. Letzteres
Verfahren konvergiert in der Regel schneller.
act
2

Die Formel für von den Gewichten der Ausgabeneuronen abhängige Fehlerfunktion des
Netzes lautet:
a 1 1
Et( w ) = ( o − y )
p
mit
a
w
n
j
o
pj
y
pj
p
2
∑ ∑ pj pj
(1)
p 2 j:
nj∈A
den Vektor der Gewichte der Neuronen der Ausgabeschicht A
Ausgabeneuron
tatsächliche Ausgabe von Neuron j über alle Muster p
erwünschte Ausgabe von Neuron j über alle Muster p
der Index der Muster
Der Faktor ½ wurde verwendet, damit er sich später gegen eine 2 wegkürzt, die durch das
Differenzieren entsteht. Zur Bestimmung optimaler Gewichte spielt es keine Rolle, ob man
den Fehler oder den halben Fehler minimiert.
Der für die unterschiedlichen Minimierungsverfahren notwendige Gradient der
Fehlerfunktion lässt sich leicht nach der für allgemeine Backpropagation-Netze
hergeleiteten Formel berechnen:
dEt
1
( w
a
) = ∑ f '
act
( net
pj
) ⋅ o
pi
( o
pj
− ypj
)
(2)
dw p
ij
p
für w
ij
Gewicht von ( ni, nj)
und nj
∈ A.
a
w
den Vektor der Gewichte der Neuronen der Ausgabeschicht
net Netzeingabe
o
pi
o
pj
y
pj
pj
die Ausgabe der Eingabezelle i für Muster p
tatsächliche Ausgabe von Neuron j über alle Muster p
erwünschte Ausgabe von Neuron j über alle Muster p
p
der Index der Muster
1
f '
act
( netpj
) = die Ableitung der Aktivierungsfunktion von Neuron j nach der
2
cosh ( net
pj
)
Netzeingabe net
pj
Ausgabeneuron
n
j
n
i
Eingabeneuron
Eine Rückpropagierung des Fehlers entfällt, da die Fehlerfunktion nur von den Gewichten
der Ausgabeneuronen abhängt.
Die Minimierung der Fehlerfunktion zur Zeit erfolgt mit einem Gradienten- oder
Koordinatenabstiegsverfahren, in der Regel jedoch mit Quickpropagation. Die Anzahl der zur
Zeit t durchgeführten Gewichtsänderungen der Ausgabeneuronen ist
implementationsabhängig. Da aber eine zufriedenstellende Entwicklung des Fehlers in
einem Anfangsstadium des gesamten Verfahrens nicht zu erwarten ist, bieten sich
Implementationen an, welche neben der Fehlerüberprüfung eine Wahl der Obergrenze der
Anzahl der durchzuführenden Modifikationen zulassen. Die Zahl der Gewichte der
Ausgabeschicht, die Größe des Netzwerkes und damit die Zahl der mathematischen
Operationen zur Berechnung von Gradient und Fehler steigen mit wachsendem t. Somit führt
3

der Algorithmus während der Fehlerminimierung für kleines t kostengünstigere
Modifikationen durch.
Sobald über eine Anzahl von Zyklen keine deutliche Änderung des Fehlers mehr zu
beobachten ist wird das Netzwerk ein letztes Mal mit der gesamten Trainingsmenge getestet
und der kumulierte Fehler gemessen. Ist dieser klein genug, terminiert das Verfahren ohne
Erzeugung verdeckter Neuronen mit einem einstufigen Netzwerk (einer Ebene trainierter
Gewichte zwischen Eingabe und Ausgabe). Im anderen Fall gibt es einen Restfehler, der
durch Einführung eines oder mehrerer verdeckter Neuronen reduziert werden muss. Es wird
ein neues verdecktes Neuron dem Netz hinzugefügt, dessen Gewichte der
Eingangsverbindungen wie nachfolgend beschrieben bestimmt werden. Sobald es
hinzugefügt ist, werden seine Gewichte eingefroren, und die Verbindungen aller Neuronen
zu den Ausgabeneuronen werden neu trainiert (ebenfalls wieder durch Quickprop). Dieser
Vorgang des Hinzufügens eines Neurons wird wiederholt, bis der Fehler klein genug ist (oder
bis die maximal tolerierbare Zeit zum Training überschritten wurde).
Zur Erzeugung einer neuen verdeckten Zelle beginnt man mit einer Kandidatenzelle j, die
trainierbare Gewichte von allen Vorgängern (Eingabezellen und vorher generierte verdeckte
Zellen) erhält, während die Ausgabe noch nicht mit dem Netzwerk verbunden ist. Nun erfolgt
eine Anzahl Durchläufe durch die gesamte Trainingsmenge, wobei die Eingabegewichte wie
folgt beschrieben geändert werden. Ziel der Änderungen ist es, die Summe der Beträge der
Korrelation (Kovarianz) zwischen der Ausgabe der Kandidatenzelle und dem Restfehler der
Ausgabezelle über alle Ausgabezellen zu maximieren.
1
S ( w ) = Cov( o , δ ) = o ⋅( δ − δ )
(3)
∑ ∑ ∑ pj j
k k k k
t j p
jn , j∈A jn , j∈A p p
k k
∂St
( w ) 1
= σ f ' ( net ) ⋅o
( δ δ )
k
j
w p
i
k
j act p pi pj
jn , j∈A p
∂
∑ ∑ − (4)
σ ( k
j
= sign ∑ o
p⋅(
δpj
−δ j
))
(5)
p
Häufig wird folgende Formel der Kovarianzsumme und ihrer Ableitung angegeben
S ( w ) = ∑∑( o −o ) ⋅( δ
j
−δ
j
)
(6)
k k k k
t p p
jn , j∈A p
k k
dSt
( w )
= σ ( δ −δ
) ⋅ f ' ( net ) o
k
pi
w
i
k
j pj j act p
jn , j∈A p
∂
∑ ∑ ⋅ (7)
k k
σ
j
= sign( ∑( op −o ) ⋅( δpj
− δ j
))
(8)
p
k
o
p
σ
j
tatsächliche Ausgabe des Kandidaten
das Vorzeichen der Korrelation zwischen der Ausgabe der Kandidatenzelle j
und dem Fehler der Ausgabezelle j für Muster p
δ
pj
der Fehler des Ausgabeneurons n
j
4

δ
j
der Durchschnittsfehler des Ausgabeneurons n
j
o
o
k
pi
k
act p 2 k
cosh ( net
p
)
die Durchschnittsausgabe des Kandidaten
die Ausgabe der Eingabezelle i für Muster p
1
f ' ( net ) = die Ableitung der Aktivierungsfunktion von Neuron j nach der
k
net
p
Netzeingabe
Netzeingabe
net
pj
k k
dSt
( w )
Nachdem der Wert von
für jedes Gewicht von der Eingabezelle i zu der
k
∂wi
Kandidatenzelle j berechnet wurde, kann man einen Gradientenaufstieg durchführen, um S
durch die Änderung der Verbindungsgewichte w ij
zu maximieren. Dies geschieht wieder
durch die Delta-Regel oder durch Quickprop für schnellere Konvergenz. Sobald sich S nicht
mehr erhöht, wird das neue verdeckte Neuron als Neuron in das aktive Netzwerk installiert,
seine Eingabeverbindungen werden eingefroren und der oben beschriebene Zyklus wird
fortgeführt.
Durch den Betrag in der Formel (3) oder (6) für S versucht ein Neuron nicht das Vorzeichen,
sondern nur den Betrag der Korrelation seiner Ausgabe mit dem Fehler der
Ausgabeneuronen zu maximieren. Wenn ein Neuron positiv mit dem Fehler einer
Ausgabezelle korreliert, bildet es eine negative Verbindung zu dieser Ausgabezelle aus, die
den Fehler vermindert; ist die Korrelation negativ, ist das Gewicht zum Ausgabeneuron
positiv. Da die Verbindungen eines Neurons zu verschiedenen Ausgabeneuronen
unterschiedliches Vorzeichen haben können, kann die gleiche verdeckte Zelle unter
Umständen zugleich eine positive Korrelation mit dem Fehler einer Ausgabezelle und eine
negative Korrelation mit dem Fehler einer anderen Ausgabezelle haben.
5

Cascade-Correlations-Verfahren anhand des XOR-Problems.
Anhand des XOR-Problems sollen im Folgenden die einzelnen Teilschritte des Cascade-
Correlations-Verfahrens detailliert erläutert werden. Die zum Training des Netzes zur
Verfügung stehende Datenmenge besteht aus vier Mustern:
Nr. Muster Eingabe Ausgabe
1 1 1 -1
2 0 1 1
3 1 0 1
4 0 0 -1
Anfangsnetz
Das Verfahren für das XOR-Problem startet mit dem Anfangsnetz gemäß Abb. 2. Die
Dimension der Eingabe ist zwei. Die Eingabeschicht enthält zusätzlich das Bias-Neuron. Die
Dimension der Ausgabe ist eins. Verdeckte Neuronen sind nicht vorhanden Für die
Ausgangskonfiguration wurden die Startgewichte willkürlich gewählt.
Abb. 2 Das Anfangsnetz ({n 1 ,n 2 ,n 3 ,n 4 }, {(n 1 ,n 4 ),(n 2 ,n 4 ),(n 3 ,n 4 )}) für das XOR-Problem
Legt man als Aktivierungsfunktion für das Ausgabeneuron den tangenshyberbolicus
f act =tanh(x) zugrunde, so erhält man bei Eingabe der Trainingsmuster die folgenden
Ausgaben:
Nr. Muster O 1 O 2 O 3 O 4
1 1 1 1 -0.379949
2 0 1 1 -0.635149
3 1 0 1 -0.148885
4 0 0 1 -0.462117
o
o
o
o
14
24
34
44
= tanh(1⋅ 0.35 + 1 ⋅( − 0.25) + 1 ⋅( − 0.50)) =−0.379949
= tanh(0⋅ 0.35 + 1 ⋅( − 0.25) + 0 ⋅( − 0.50)) =−0.635149
= tanh(1⋅ 0.35 + 0 ⋅( − 0.25) + 1 ⋅( − 0.50)) =−0.148885
= tanh(0⋅ 0.35 + 0 ⋅( − 0.25) + 1 ⋅( − 0.50)) =−0.462117
6

Fehlerminimierung
Der Cascade-Algorithmus minimiert nur von den Gewichten der Ausgabeneuronen
abhängigen Fehler.
Cascade-Fehlerfunktion zur Zeit t
Für das XOR-Problem ergeben sich folgende Teilberechnungen und Modifikationen:
Vor Beginn der Gewichtsveränderung durch die Lernregel Quickpropagation ergibt sich
folgender Funktionswert der Fehlerfunktion Nach der Formel (1):
4
1 1
2
0( 14, 24, 34) = ∑ (
p4 −
p4)
4 p=
1 2
E w w w o y
11 [( 0.379949 ( 1)) ( 0.635149 1)
42
+− − + − −− =
2 2
− − − + − − +
2 2
( 0.148885 1) ( 0.462117 ( 1)) ] 0.5834288
Im Laufe der Fehlerminimierung zur Zeit t=0 ergeben sich folgende Werte nach Formeln (1)
und (2):
net
net
net
net
14
24
34
44
= 1⋅ 0.35 + 1 ⋅( − 0.25) + 1 ⋅( − 0.50) =−0.40
= 0⋅ 0.35 + 1 ⋅( − 0.25) + 1 ⋅( − 0.50) =−0.75
= 1⋅ 0.35 + 0 ⋅( − 0.25) + 1 ⋅( − 0.50) =−0.15
= 0⋅ 0.35 + 0 ⋅( − 0.25) + 1 ⋅( − 0.50) =−0.50
f
f
f
f
'
act
'
act
'
act
'
act
1
( net14) = = 0.855639
2
cosh ( −0.40)
1
( net24) = = 0.596586
2
cosh ( −0.75)
1
( net34) = = 0.977833
2
cosh ( −0.15)
1
( net44) = = 0.786448
2
cosh ( −0.50)
o
o
o
o
− y =−0.379949 −( − 1) = 0.620051
14 14
− y =−0.635149 − 1 =−1.635149
24 24
− y =−0.148885 − 1 =−1.148885
34 34
− y =−0.462117 −( − 1) = 0.537883
44 44
7

grad( E ( w , w , w )) =
4
p=
1
o
14 24 34
1 [ ( ) ( ); ( ) (
4
∑
4 4
'
'
∑ fact net
p4 ⋅op1 op4 − y
p4 ∑ fact net
p4 ⋅op2 op4 − y
p4
p= 1 p=
1
f ( net ) ⋅o ( o − y )] =
'
act p4 p3 p4 p4
1
= [0.855639 ⋅ 1 ⋅ 0.620051 + 0.596586 ⋅ 0 ⋅ ( − 1.635149) +
4
+ 0.977833⋅1 ⋅( − 1.148885) + 0.786448⋅0⋅0.537883;
0.855639⋅1⋅ 0.620051+ 0.596586⋅1 ⋅( − 1.635149) +
+ 0.977833⋅0 ⋅( − 1.148885) + 0.786448⋅0⋅0.537883;
0.855639⋅1⋅ 0.620051+ 0.596586⋅1 ⋅( − 1.635149) +
+ 0.977833⋅1 ⋅( − 1.148885) + 0.786448⋅1⋅ 0.537883] =
1
= [ − 0.592878; −0.444967; − 1.145368] =
4
= [ −0.148220; −0.111242; −0.286342]
);
a
( w (0)) = ( −0.1 ⋅( −0.148220); −0.1 ⋅( −0.111242); −0.1 ⋅( −0.286342))
= (0.0148220;0.0111242;0.0286342)
a
w (1) = (0.35 + 0.0148220; − 0.25 + 0.0111242; − 0.5 + 0.0286342) =
= (0.364822; −0.238876; −0.471366)
usw.
w a (0) ( 0.350000, -0.250000, -0.500000)
E 0 (w a (0)) 0.5834288
grad(E 0 (w a (0))) ( -0.148220, -0.111242, -0.286342)
Δ(w a (0)) ( 0.014822, 0.0111242, 0.0286342)
w a (1) ( 0.364822, -0.238876, -0.471366)
E 0 (w a (1)) 0.5723144
grad(E 0 (w a (1))) ( -0.124930, -0.103962, -0.264260)
…
w a (187) ( 0.014772, 0.006055, -0.012307)
E 0 (w a (187)) 0.5000337
8

Das Netz hat nach Abschluss dieser Phase folgendes Aussehen:
Abb. 3 Das durch die Fehlerminimierung zur Zeit t=0 veränderte Ausgangsnetz des XOR-Problems
Das Netz liefert nun folgende Ausgaben und Fehler bei Anlegen der Trainingsmenge:
Nr. Muster O 1 O 2 O 3 O 4
δ
4
1 1 1 1 0.008519 1.008519
2 0 1 1 -0.006253 -1.006253
3 1 0 1 0.002465 -0.997535
4 0 0 1 -0.012307 0.987693
o
o
o
o
14
24
34
44
44
= tanh(1⋅ 0.014772 + 1⋅ 0.006055 + 1 ⋅( − 0.012307)) = 0.008519
= tanh(0⋅ 0.014772 + 1⋅ 0.006055 + 1 ⋅( − 0.012307)) =−0.006253
= tanh(1⋅ 0.014772 + 0⋅ 0.006055 + 1 ⋅( − 0.012307)) = 0.002465
= tanh(0⋅ 0.014772 + 0⋅ 0.006055 + 1 ⋅( −0.
012307)) =−0.012307
δ14
= 0.008519 −( − 1) = 1,008519
δ24
=−0.006253 − 1 =−1.006253
δ34
= 0.002465 − 1 =−0.997535
δ =−0.012307 −( − 1) = 0.987693
Überprüfung auf Abbruch
Das Verfahren entscheidet nach Durchführung der Fehlerminimierung, ob ein zur Lösung
des Problems günstiger Endzustand des Netzes erreicht ist oder nicht.
Für das betrachtete XOR-Problem sei als Abbruchkriterium festgelegt, dass das Training
beendet wird, wenn ein Fehlerwert von 0.0025 unterschritten wird.
Da der Fehler des in Abb. 3 dargestellten Netzes noch bei 0.5000337 liegt, fährt der
Algorithmus mit der Durchführung des Kandidatentrainings fort.
9

Kandidatentraining
Das Verfahren erzeugt ein neues Neuron, initialisiert zufällig dessen Gewichte und
modifiziert diese innerhalb einer Trainingsprozedur. Das Neuron erhält während seines
Trainings Eingaben von allen Neuronen der Eingabeschicht und allen verborgenen
Schichten.
Das Kandidatenneuron beeinflusst die Ausgabe des Netzes nicht, da es keinerlei
Informationen in das Netzwerk leitet. Insbesondere besteht keinerlei Verbindung des
Kandidaten zu den Neuronen der Ausgabeschicht. Ziel des Kandidatentrainings ist die
Bestimmung der Gewichte einer weiteren verborgenen Schicht, deren Einfügung sich positiv
auf die zukünftige Fehlerentwicklung auswirkt.
Um die Auswirkung des potentiellen Einfügens eines Kandidaten in das Netz zu beurteilen,
wird der Korrelationskoeffizient betrachtet.
Im Fall des XOR-Problems befindet sich das aktuelle Netz immer noch im Zustand t=0. Es
k
wird ein Neuron n mit einem dreidimensionalen Gewichtsvektor erzeugt. Als
Aktivierungsfunktion seit fact
( x ) = tanh( x ) gewählt. Die Abb. 4 demonstriert diese Situation.
Kovarianzsumme
Das Kandidatenneuron liefert folgende Ausgaben bei Anlegen der Eingabedaten an das
Netz:
Nr. Muster O 1 O 2 O 3
k
O
1 1 1 1 -0.197375
2 0 1 1 -0.996682
3 1 0 1 -0.761594
4 0 0 1 -0.999329
o
o
o
o
k
1
k
2
k
3
k
4
= tanh(1⋅ 3.00 + 1⋅ 0.80 + 1 ⋅( − 4.00)) =−0.197375
= tanh(0⋅ 3.00 + 1⋅ 0.80 + 1 ⋅( − 4.00)) =−0.996682
= tanh(1⋅ 3.00 + 0⋅ 0.80 + 1 ⋅( − 4.00)) =−0.761594
= tanh(0⋅ 3.00 + 0⋅ 0.80 + 1 ⋅( − 4.00)) =−0.999329
Anschließend verändert das Verfahren die Gewichte des Kandidatenneurons durch
k k k k
Maximierung der Kovarianzsumme S ( w , w , w ) nach Formel (3), die zur Zeit t=0
folgenden Wert annimmt:
0 1 2 3
1
S (3.00,0.80, − 4.00) = ⋅( − ) =
4
k
k
0 ∑op
δp4 δ4
p p=
1
1
= ( − 0.197375 ⋅ 1.010413 + ( − 0.996682) ⋅ ( − 1.004359) +
4
+− ( 0.761594) ⋅− ( 0.995641) + ( −0.999329) ⋅ 0.989587 =
1
= 0.570947 = 0.1427369
4
δ
4
= (1.008519 −1.006253 − 0.997535 + 0.987693) / 4 =− 0.001894
10

δ − δ = 1.008519 −( − 0.001894) = 1.010413
14 4
δ − δ =−1.006253 −( − 0.001894) =−1.004359
24 4
δ − δ =−0.997535 −( − 0.001894) =−0.995641
34 4
δ − δ = 0.987693 −( − 0.001894) = 0.989587
44 4
Nach Formeln (4) und (5) wird weiter berechnet:
σ
4
=+ 1
net
net
net
net
k
1
k
2
k
3
k
4
= 1⋅ 3.00 + 1⋅ 0.80 + 1 ⋅( − 4.00) =−0.20
= 0⋅ 3.00 + 1⋅ 0.80 + 1 ⋅( − 4.00) =−3.20
= 1⋅ 3.00 + 0⋅ 0.80 + 1 ⋅( − 4.00) =−1.00
= 0⋅ 3.00 + 0⋅ 0.80 + 1 ⋅( − 4.00) =−4.00
f
f
f
f
'
act
'
act
'
act
'
act
k 1
( net1 ) = = 0.961043
2
cosh ( −0.20)
k 1
( net2 ) = = 0.006624
2
cosh ( −3.20)
k 1
( net3 ) = = 0.419974
2
cosh ( −1.00)
k 1
( net4 ) = = 0.001341
2
cosh ( −4.00)
1
grad( S ( w (0))) = [ f ( net ) ⋅o
⋅( − )] =
4
k
' k
o 4 act p pi p4 4
p σ ∑
δ δ
p=
1
1
= (0.961043 ⋅ 1 ⋅ 1.010413 + 0.006624 ⋅ 0 ⋅ ( − 1.004359) +
4
+ 0.419974⋅1 ⋅( − 0.995641) + 0.001341⋅0⋅0.989587;
0.961043⋅1⋅ 1.010413+ 0.006624⋅1 ⋅( − 1.004359) +
+ 0.419974⋅0 ⋅(
− 0.995641) + 0.001341⋅0⋅0.989587;
0.961043⋅1⋅ 1.010413 + 0.006624⋅1 ⋅( − 1.004359) +
+ 0.419974⋅1 ⋅( − 0.995641) + 0.001341⋅1⋅ 0.989587) =
1
= (0.55290;0.964397;0.547581) = (0.138227;0.241099;0.136895)
4
k
( w (0)) = (0.35⋅0.138227;0.35⋅0.241099;0.35⋅0.136895)
= (0.048379;0.084385;0.047913)
11

k
w
(1) = (3.00 + 0.048379;0.80 + 0.084385; − 4.00 + 0.047913) =
= (3.048379;0.884385; −3.952087)
usw.
Abb. 4 Einfügen eines Kandidatenneurons beim XOR-Problem
Im Laufe des Kandidatentrainings berechnet das Verfahren die folgenden Werte:
w k (0) ( 3.000000, 0.800000, -4.000000)
S 0 (w k (0)) 0.1427369
grad(S 0 (w k (0))) ( 0.138227, 0.241099, 0.136895)
Δ(w k (0)) ( 0.048379, 0.084385, 0.047913)
w k (1) ( 3.048379, 0.884385, -3.952087)
S 0 (w k (1)) 0.1766525
grad(S 0 (w k (1))) ( 0.131953, 0.250344, 0.130153)
…
w k (391) ( 3.998832, 3.992753, -6.078353)
S 0 (w k (391)) 0.4791468
Zum Abschluss der Kandidaten-Trainingsphase hat der Kandidat das Aussehen:
Abb. 5 Das Kandidatenneuron im Anschluss an die Trainingsphase
12

Einfügung der neuen Schicht
Beim XOR-Problem integriert das Verfahren nun das Kandidatenneuron aus Abb. 5 in das in
Abb. 3 dargestellte Netz.
Abb. 6 Das Netz für das XOR-Problem nach dem Einfügen einer neuen Schicht.
k
Das Verfahren baut das trainierte Kandidatenneuron n in das Netzwerk ein. Die
Verbindungen des Kandidaten werden feste Verbindungen des Netzes (graue Quadrate).
Das schwarze Quadrat ist das neue Gewicht der ganz neuen Verbindungen zu dem
Ausgabeneuron. Das neue Gewicht wird mit einem negativen Wert initialisiert, da die
k
Korrelation des Kandidaten n zu dem Ausgabeneuron ein positives Vorzeichen hatte. Das
Cascade-Netz zur Zeit t=0 hat sich zu einem Cascade-Netz zur Zeit t=1 verändert.
Die Neuronen des Netzes liefern nun folgende Werte bei Anlegen der Trainingsmenge:
Nr. Muster O 1 O 2 O 3 O 4 O 5 δ
5
1 1 1 1 0.957356 -0.039328 0.960672
2 0 1 1 -0.969602 0.042202 -0.957798
3 1 0 1 -0.969236 0.050883 -0.949117
4 0 0 1 -0.999989 0.037674 1.037674
o
o
o
o
14
24
34
44
= tanh(1⋅ 3.998832 + 1⋅ 3.992753 + 1 ⋅( − 6.078353)) = 0.957356
= tanh(0⋅ 3.998832 + 1⋅ 3.992753 + 1 ⋅( − 6.078353)) =−0.969602
= tanh(1⋅ 3.998832 + 0⋅ 3.992753 + 1 ⋅( − 6.078353)) =−0.969236
= tanh(0⋅ 3.998832 + 0⋅ 3.992753+ 1 ⋅( −6.078353)) =−0.999989
o
o
o
o
15
25
35
45
= tanh(1⋅ 0.014772 + 1⋅ 0.006055 + 1 ⋅( − 0.012307) + 0.957356 ⋅( − 0.05)) =−0.039328
= tanh(0⋅ 0.014772 + 1⋅ 0.006055 + 1 ⋅( − 0.012307) + ( −0.969602) ⋅( − 0.05)) = 0.042202
= tanh(1⋅ 0.014772 + 0⋅ 0.006055 + 1 ⋅(
−0.012307) + ( −0.969236) ⋅( − 0.05)) = 0.050883
= tanh(0⋅ 0.014772 + 0⋅ 0.006055 + 1 ⋅( − 0.012307) + ( −0.999989) ⋅( − 0.05)) = 0.037674
13

δ =−0.039328 −( − 1) = 0.960672
δ
15
25
35
45
= 0.042202 − 1 =−0.957798
δ = 0.050883− 1 =−0.949117
δ
= 0.037674 −( − 1) = 1.037674
Das Verfahren fährt jetzt mit der Fehlerminimierung zur Zeit t = 1 fort, indem es die,
mittlerweile um eines vermehrten, Gewichte des Ausgabeneurons modifiziert.
Im Laufe der Fehlerminimierung zur Zeit t = 1 ergeben sich folgende Werte:
w a (0) ( 0.014772, 0.006055, -0.012307, -0.050000)
E 1 (w a (0)) 0.4772323
grad(E 1 (w a (0))) ( 0.003131, 0.000773, 0.023159, 0.431664)
Δ(w a (0)) ( -0.002975, -0.000735, -0.022001, -0.410081)
w a (1) ( 0.011797, 0.005320, -0.034308, -0.460081)
E 1 (w a (1)) 0.3773563
grad(E 1 (w a (1))) ( -0.009315, -0.011070, 0.156739, 0.064021)
…
w a (696) ( 3.303277, 3.302020, -5.047390, -3.546423)
E 1 (w a (696)) 0.0024969
Das Netz aus Abb. 6 hat am Ende der Fehlerminimierung folgendes Aussehen:
Abb. 7 Das zur Lösung des Beispielproblems entwickelte Netz nach Abschluss der Fehlerminimierung
zur Zeit t = 1.
14

Nach Abschluss der Fehlerminimierung zur Zeit t = 1 liefert das Netz diese Ausgaben:
Nr. Muster Eingabe Erwünschte
Ausgabe
Tatsächliche
Ausgabe
1 1 1 -1 -0.950534
2 0 1 1 0.934560
3 1 0 1 0.934554
4 0 0 -1 -0.905329
Das Verfahren legt nun erneut das Abbruchkriterium an, um zu entscheiden, ob er ein neues
Kandidatenneuron trainiert oder aber das Gesamtverfahren beenden soll.
Da der Wert der Fehlerfunktion E ( a 1
w ) die vorgegebene Grenze von 0.0025 unterschreiten
konnte, beendet das Verfahren an dieser Stelle das Training. Die endgültige Struktur des
Netzes entspricht nun der in Abb. 7.
15

Quellen:
Zell A. Simulation Neuronaler Netze
Lippe W. Soft-Computing
16