Prof. Sauer - oth

Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Prof. Jürgen Sauer
Neuronale Netze, Fuzzy Control-Systeme und
Genetische Algorithmen
Skriptum zur Vorlesung im WS 2007 / 2008
1
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Inhaltsverzeichnis
1. Grundlagen .......................................................................................................................................................... 8
1.1 Einführung..................................................................................................................................................... 8
1.1.1 Biologische bzw. psychologische Grundlagen ....................................................................................... 8
1.1.2 Überführung in ein datentechnisches Verarbeitungsmodell (NN) .......................................................... 9
1.2 Wie arbeiten Neuronale Netzwerke? ........................................................................................................... 10
1.2.1 Ein einführendes Beispiel ..................................................................................................................... 10
1.2.2 Allgemeiner Aufbau neuronaler Netze ................................................................................................. 17
1.2.3 Informationsverarbeitung in neuronalen Netzen .................................................................................. 24
1.2.4 Mathematische Grundlagen zum Lernverhalten NN ............................................................................ 26
1.2.5 Implementierung NN ............................................................................................................................ 27
2. Wichtige Ausprägungen NN ............................................................................................................................. 28
2.1 Modellierung Neuraler Netze ...................................................................................................................... 28
2.1.1 Übersicht .............................................................................................................................................. 28
2.1.2 Topologien ........................................................................................................................................... 29
2.1.2.1 Definition NN ................................................................................................................................ 29
2.1.2.2 Netze ohne Rückkopplung, „feedforward“-Netze ......................................................................... 30
2.1.2.3 Netze mit Rückkopplungen, „rekurrente Netze“ ........................................................................... 30
2.2 Interaktive Netzwerke ................................................................................................................................. 31
2.2.1 Beschreibung ........................................................................................................................................ 31
2.2.1.1 Arbeitseinheiten ............................................................................................................................ 31
2.2.1.2 Netzarchitektur .............................................................................................................................. 33
2.2.2 Mathematische Grundlagen .................................................................................................................. 35
2.2.3 Implementierung des IAC-Modells ...................................................................................................... 37
2.3 Klassifikatoren und Musterassoziatoren ...................................................................................................... 40
2.3.1 Beschreibung ........................................................................................................................................ 40
2.3.2 Grundlagen ........................................................................................................................................... 41
2.3.2.1 Die Hebbsche Hypothese ............................................................................................................. 42
2.3.2.2 Die Hebbsche Hypothese in Musterassoziator-Modellen .............................................................. 44
2.3.2.2.1 Lernphase ............................................................................................................................... 44
2.3.2.2.2 Testphase ................................................................................................................................ 44
2.3.2.2.3 Beispiele ................................................................................................................................. 45
2.3.2.2.3.1 Beispiel 1 ......................................................................................................................... 45
2.3.2.2.3.2 Beispiel 2 ......................................................................................................................... 47
2.3.2.3 Delta-Regel (Widrow&Hoff-Regel) ............................................................................................. 49
2.3.2.4 Die Delta-Regel in Musterassoziator-Modellen ............................................................................ 50
2.3.3 Implementierung .................................................................................................................................. 51
2.3.4 Das Perzeptron ..................................................................................................................................... 56
2.3.4.1 Biologische Grundlagen ................................................................................................................ 56
2.3.4.2 Funktionsweise .............................................................................................................................. 56
2.3.4.3 Lernen mit der Delta-Regel ........................................................................................................... 57
2.3.4.4 Lineare Trennbarkeit ..................................................................................................................... 58
2.3.4.5 Applet: Perzeptron-Netz zur Rekodierung von Zahlen ................................................................. 62
2.3.4.6 Adaline und Madaline ................................................................................................................... 63
2.3.4.6.1 Adaline-Modell ...................................................................................................................... 63
2.3.4.6.2 Madaline-Modell .................................................................................................................... 65
2.3.4.7 Linear separierbare Probleme ........................................................................................................ 67
2.3.4.8 Nicht linear trennbare Klassifizierer.............................................................................................. 73
2.3.5 Multilayer-Netwerk .............................................................................................................................. 81
2.4 Backpropagation Netzwerke ....................................................................................................................... 84
2.4.1 Beschreibung ........................................................................................................................................ 84
2.4.2 Grundlagen ........................................................................................................................................... 86
2.4.2.1 Herleitung des Backpropagation Algorithmus .............................................................................. 86
2.4.2.2 Verlauf der Fehlerfunktion ............................................................................................................ 90
2.4.2.2.1 Lokale Minima ....................................................................................................................... 90
2.4.2.2.2 Symmetric Breaking ............................................................................................................... 91
2.4.2.2.3 Flache Plateaus ....................................................................................................................... 92
2.4.2.2.4 Oszillation .............................................................................................................................. 93
2
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.2.2.5 Verlassen guter Minima ......................................................................................................... 94
2.4.2.3 Möglichkeiten zur Behebung der Problemfälle ............................................................................. 94
2.4.2.4 Festlegen von Parameterwerten ..................................................................................................... 95
2.4.2.4.1 Lernrate  .............................................................................................................................. 95
2.4.2.4.2 Momentum ............................................................................................................................. 95
2.4.2.4.3 Die Anzahl der inneren Einheiten........................................................................................... 95
2.4.2.5 Testphase (Recall) ......................................................................................................................... 96
2.4.3 Implementierung .................................................................................................................................. 96
2.4.3.1 Lösung des XOR-Problems mit einem Java-Programm ................................................................ 96
2.4.3.2 Applet zur Lösung des XOR-Problems mit einem Backpropagation-Netzwerk .......................... 102
2.4.5 Modifikationen ................................................................................................................................... 103
2.4.5.1 Momentum-Version .................................................................................................................... 103
2.4.5.2 Weight Decay .............................................................................................................................. 104
2.4.5.3 Quickprop.................................................................................................................................... 106
2.4.5.4 Resilient Backpropagation .......................................................................................................... 107
2.4.5 Anwendungen ..................................................................................................................................... 110
2.4.5.1 Simulator für Backpropagation-Netze ......................................................................................... 110
2.4.5.2 Kreuzprodukt............................................................................................................................... 110
2.4.5.3 BPN-Robot .................................................................................................................................. 110
2.5 Rekurrente Netze ....................................................................................................................................... 111
2.5.1 Auto-assoziative Netze ....................................................................................................................... 111
2.5.1.1 Aufbau ......................................................................................................................................... 111
2.5.1.2 Grundlagen .................................................................................................................................. 112
2.5.1.3 Das "Brain-State-in-the-Box"-Modell ......................................................................................... 118
2.5.2 Hopfield-Netze ................................................................................................................................... 121
2.5.3 Partiell rekrurrente Netze ................................................................................................................... 122
2.5.3.1 Jordan-Netze ............................................................................................................................... 122
2.5.3.2 Elman-Netze ................................................................................................................................ 123
2.6 Thermodynamische Modelle ..................................................................................................................... 125
2.6.1 Das Hopfield-Modell ......................................................................................................................... 125
2.6.1.1 Beschreibung ............................................................................................................................... 125
2.6.1.2 Berechnungsgrundlagen .............................................................................................................. 126
2.6.1.3 Mustererkennung mit Hopfield-Netzen ....................................................................................... 131
2.6.1.4 Anwendungen zur Mustererkennung ........................................................................................... 133
2.6.1.4.1 Applet zur Mustererkennung mit dem Hopfield-Netz .......................................................... 133
2.6.1.4.2 Bildmustererkennung mit Hilfe des Hopfield-Netzes ........................................................... 134
2.6.1.5 Optimierungsaufgabe: Lösung des TSP mit Hopfield-Netzen..................................................... 135
2.6.1.6 Lösung des N-Damen-Problems .................................................................................................. 138
2.6.2 Das Guarded-Discrete-Stochastic-Netzwerk (GDS)........................................................................... 142
2.6.2.1 Beschreibung ............................................................................................................................... 142
2.6.2.2 Algorithmus zum "Damen-Problem" mit einem GDS-Netzwerk ................................................ 142
2.6.2.3. Das Applet zur Lösung des N-Damen-Problems mit einem GDS-Netwerk ............................... 144
2.6.2.4. Erläuterungen zur Implementierung ........................................................................................... 145
2.6.3 BAM .................................................................................................................................................. 146
2.6.3.1 Beschreibung ............................................................................................................................... 146
2.6.3.2 Lernen ......................................................................................................................................... 147
2.6.3.3 Energiefunktion ........................................................................................................................... 148
2.6.3.4 Abruf ........................................................................................................................................... 149
2.6.3.5 Kapazität ..................................................................................................................................... 151
2.6.3.6 Applet: Mustererkennung mit BAM ............................................................................................ 151
2.6.4 Simulated Annealing .......................................................................................................................... 152
2.6.4.1 Beschreibung ............................................................................................................................... 152
2.6.4.2 Berechnung ................................................................................................................................. 153
2.6.4.3 Der Simulated-Annealing Algorithmus ....................................................................................... 155
2.6.4.4 Das Applet zur Lösung des TSP mit Simulated Annealing ......................................................... 156
2.6.4.5 Threshold Accepting (TA) (Schwellenakzeptanz) ...................................................................... 157
2.6.5 Boltzmann Maschine .......................................................................................................................... 158
2.6.5.1 Beschreibung ............................................................................................................................... 158
2.6.5.2 Der Algorithmus .......................................................................................................................... 160
2.6.5.3 Implementierung ......................................................................................................................... 161
3
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.5.4 Das Applet ................................................................................................................................... 167
2.7 Wettbewerbslernen (Competitive Learning) ............................................................................................. 168
2.8 Selbstorganisierende Netze ....................................................................................................................... 171
2.8.1 Sensorische Karten (SOMs) ............................................................................................................... 171
2.8.1.1 Beschreibung ............................................................................................................................... 171
2.8.1.2 Lernverfahren: Bestimmen der Gewichte .................................................................................... 174
2.8.1.3 Implementierungsbeispiele .......................................................................................................... 175
2.8.1.3.1 Simulationsbeispiel mit eindimensionaler Eingabe .............................................................. 175
2.8.1.3.2 Simulationsbeispiele mit zweidimensionalen Eingaben ....................................................... 175
2.8.1.3.2.1 Eindimensionales Gitter der Neuronenkette ...................................................................... 175
2.8.1.3.2.1.1 Streckenförmige Anordnung der Neuronenkette ........................................................ 175
2.8.1.3.2.1.2 Kreisförmige Anordnung der Neuronenkette ............................................................. 176
2.8.1.3.2.2 Zweidimensionale Gitterstruktur ....................................................................................... 177
2.8.1.4 Anwendungen .............................................................................................................................. 178
2.8.1.4.1 Zeichenerkennung mit Kohonen Feature Map...................................................................... 178
2.8.1.4.1 Zahlenerkennung mit Kohonen Feature Map ....................................................................... 178
2.8.1.4.2 Spracherkennung .................................................................................................................. 178
2.8.2 Motorische Karten .............................................................................................................................. 179
2.8.2.1 Beschreibung ............................................................................................................................... 179
2.8.2.2 Lernverfahren .............................................................................................................................. 180
2.8.2.3 Anwendungen .............................................................................................................................. 181
2.8.2.3.1 Kohonnen-Wippe ................................................................................................................. 181
2.8.2.3.2 Auffangen eines Balls ........................................................................................................... 182
2.9 RBF-Netze ................................................................................................................................................ 184
2.9.1 Grundlagen ......................................................................................................................................... 184
2.9.2 Einstellen der Gewichte, Anpassen bzw. Wahl der Zentren und Breiten ........................................... 185
2.9.2.1 Einstellen der Gewichte ............................................................................................................... 185
2.9.2.2 Anpassen bzw. Wahl der Zentren und Breiten ............................................................................ 187
2.10 ART ......................................................................................................................................................... 188
2.10.1 Einführung........................................................................................................................................ 188
2.10.2 Struktur............................................................................................................................................. 188
2.10.3 Lernen im ART-Netzwerk ................................................................................................................ 188
2.10.4 Leistungen und Grenzen vom ART .................................................................................................. 188
2.11 Counter Propagation................................................................................................................................ 189
2.11.1 Die Netzstruktur ............................................................................................................................... 189
2.11.2 Lernvorgänge in den Schichten ........................................................................................................ 191
3. Fuzzy-Systeme ................................................................................................................................................ 192
3.1 Fuzzy-Logik .............................................................................................................................................. 192
3.1.1 Einführung in die Denkweise ............................................................................................................. 192
3.1.1.1 Unscharfe Mengen (Fuzzy-Sets) ................................................................................................. 192
3.1.1.2 Funktionstyp ................................................................................................................................ 193
3.1.1.3 Operatoren auf Fuzzy-Mengen .................................................................................................... 193
3.1.1.4 Linguistische Variable ................................................................................................................. 194
3.1.1.5 Fuzzy-Regeln............................................................................................................................... 195
3.1.1.6 Unscharfe Relationen .................................................................................................................. 196
3.1.2 Verarbeitung in Fuzzy-Systemen: Fuzzy-Inferenz ............................................................................. 199
3.1.2.1 Ein einführendes Beispiel ............................................................................................................ 199
3.1.2.2 Fuzzy-Inferenzschema ................................................................................................................. 203
3.1.2.3 Anwendungen .............................................................................................................................. 208
3.1.2.3.1 Anwendungsbeispiel: Berg- und Talfahrt eines Fahrzeugs................................................... 208
3.1.2.3.2 Anwendungsbeispiel: Roboter-Steuerung mit Fuzzy-Control .............................................. 213
3.1.2.3.3 Anwendungsbeispiel: Beetle-Driver ..................................................................................... 213
3.1.2.3.4 Anwendungsbeispiel: Kugeldrum......................................................................................... 213
3.1.2.3.5 Anwendungsbeispiel: PingPong (KHF vs FC) ..................................................................... 213
3.1.3 Regelbasierte Systeme ........................................................................................................................ 214
3.1.3.1 Fuzzy-Logik regelbasierter Systeme ........................................................................................... 214
3.1.3.2 Defuzzifizierung .......................................................................................................................... 215
3.1.3.2.1 Methode der plausibelsten Lösung ....................................................................................... 215
3.1.3.2.2 Methode des besten Kompromiss ......................................................................................... 216
3.1.3.3 Anwendungen .............................................................................................................................. 218
4
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.3.3.1 Inverses Pendel ..................................................................................................................... 218
3.1.3.3.2 Fuzzy-Truck-Trailer ............................................................................................................. 222
3.1.3.3.3 Kugelkasten .......................................................................................................................... 222
3.1.3.3.4 Water-Mix ............................................................................................................................ 222
3.1.3.3.5 Demonstration einer Fuzzy-Logik Steuerung eines Rennwagens durch eine Rennstrecke ... 222
3.1.3.3.6 Fuzzy-Robot ......................................................................................................................... 222
3.1.4 Mamdani und Fuzzy-Regler vom Typ Sugeno ................................................................................... 223
3.1.5 Fuzzy Associative Memories (FAM) ................................................................................................. 225
3.1.5.1 Verknüpfungen zwischen Fuzzy-Systemen ................................................................................. 225
3.1.5.2 Adaptive FAMs ........................................................................................................................... 227
3.1.5.3 Erzeugen von adaptiven FAM-Regeln ........................................................................................ 227
3.1.5.4 Adaptives BIOFAM-Clustering .................................................................................................. 228
3.2 Regelungssysteme ..................................................................................................................................... 229
3.2.1 Klassische Regelungssysteme ............................................................................................................ 229
3.2.1.1 Begriffe aus der Regelungstechnik .............................................................................................. 229
3.2.1.2 Beschreibungsmöglichkeiten (für dynamische Systeme) ............................................................. 230
3.2.1.3 Lineare (stetige) Regler ............................................................................................................... 235
3.2.1.4 Zustandsregler ............................................................................................................................. 240
3.2.1.5 Kennlinien- und Kennfeldregler .................................................................................................. 241
3.2.2 Fuzzy-Regelungssysteme ................................................................................................................... 242
3.2.2.2 Einfaches Modell eines Fuzzy-Reglers........................................................................................ 246
3.2.2.2.1 Diskrete Regelung ................................................................................................................ 246
3.2.2.2.2 Fuzzy-Regelung .................................................................................................................... 246
3.2.3 Hybride Systeme ................................................................................................................................ 248
3.2.3.1 Neuronale Regler......................................................................................................................... 248
3.2.3.2 Vergleich Neuronale Netze mit Fuzzy-Systemen in Hinblick auf Schätzungen zu Ein/Ausgabefunktionen (Regeln) .................................................................................................................. 249
3.2.3.3 Kombinationen Neuronaler Netze und Fuzzy-Regler (Neuro-Fuzzy) ......................................... 251
3.2.3.4 Neuro-FuzzyHybride ................................................................................................................... 253
3.2.3.4.1 NEFCON bzw. NEFCLASS................................................................................................. 253
3.2.3.4.2 Anfis ..................................................................................................................................... 256
3.2.3.4.2.1 Anfis-Netze für unterschiedliche Typen von Fuzzy-Kontrollern................................... 256
3.2.3.4.2.2 Lernregel für Anfis-Netze ............................................................................................. 260
4. Konzept und Arbeitsweise genetischer Algorithmen....................................................................................... 261
4.1 Evolution und Genetik............................................................................................................................... 261
4.2 Prinzipielle Arbeitsweise genetischer Algorithmen ................................................................................... 262
4.2.1 Arbeitsweise von genetischen Algorithmen ....................................................................................... 262
4.2.2 Struktur eines genetischen Algorithmus ............................................................................................. 263
4.3 Phasen eines genetischen Suchalgorithmus ............................................................................................... 264
4.3.1 Modellierung ...................................................................................................................................... 264
4.3.2 Konfigurierung ................................................................................................................................... 264
4.3.3 Die Realisierungsphase ...................................................................................................................... 269
4.3.4 Verfahrensbewertung bzw. Verfahrensverbesserung.......................................................................... 273
4.3.5 Güte eines genetischen Algorithmus .................................................................................................. 273
4.5 Anwendungen ............................................................................................................................................ 274
4.5.1 Ein genetischer Algorithmus für das Problem des Handlungs-reisenden ........................................... 274
4.5.2 Ein genetischer Algorithmus für das Packproblem ............................................................................ 276
4.5.3 Genetic Function Finder ..................................................................................................................... 284
5
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Empfohlene Literatur
Rummelhart, David E. und McClelland, James L.: Parallel Distributed Processing, Cambridge
Massachusets, MIT Press 1989
Kinnebrok, W.: Neuronale Netze , R. Oldenbourg Verlag, Müchen/Wien 1992
Kruse, Hilger u.a.: Programmierung Neuronaler Netze, Addison-Wesley, 1. Auflage 1991,
Bonn ...
Schöneburg, E. u.a.: Neuronale Netwerke, Markt & Technik, Haar bei München, 1990
Müller, B. u. Reinhardt, J.: Neural Networks, Springer Verlag, Berlin, 1990
Schöneburg, E. (Hrsg.): Industrielle Anwendung Neuronaler Netze, Addison-Wesley, Bonn
...., 1993
Nauk, Detlef u. Klawonn,Frank u. Kruse, Rudolf: Neuronale Netze und Fuzzy-Systeme,
Vieweg, Braunschweig/Wiesbaden, 1994
Mayer, Andreas u.a.: Fuzzy Logic, Addison-Wesley, Bonn ...... ,1993
Kahlert, Jörg u. Frank, Hubert : Fuzzy-Logik und Fuzzy-Control, Vieweg,
Braunschweig/Wiesbaden, 1993
Kosko, Bart: Neural Networks and Fuzzy Systems, Prentice Hall, Englewood Ciffs NJ, 1992
Tilli, Thomas: Mustererkennung mit Fuzzy-Logik, Franzis Verlag, München 1993
Tilli, Thomas: Automatisierung mit Fuzzy-Logik, Franzis-Verlag, München 1992
Tilli, Thomas; Fuzzy-Logik, Franzis-Verlag, München 1991
Goldberg, David E.: Genetic Algorithms in Search, Optimization, and Machine Learning,
Addison-Wesley, Reading, Massachusetts 1989
6
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Diplomarbeiten an der F.H. Regensburg
Christian Dirnberger: Entwurf und Lösung des Stabbalance Problems über neuronale Netze
und Fuzzy Control Systeme unter Objectworks / Smalltalk
Jochen Fröhlich: Komponenten Neuronaler Netze in einer objektorientierten Klassenstruktur
http://fbim.fh-regensburg.de/~saj39122/jfroehl/diplom/e-index.html
Gerhard Heinz: Fuzzy-Logik und Fuzzy-Control am Bsp. des invertierten Pendels,
Darstellung des Problems und seine Lösung.
http://fbim.fh-regensburg.de/~saj39122/gheinz/Index.html
Thomas Feldbauer: Fahrzeugsteuerung auf einem frei definierbaren Rundkurs über ein FuzzyControl-System mit Erlernen der Fahrweise über Speicherung in einem Neuronalen Netz
http://fbim.fh-regensburg.de/~saj39122/feld/diplomarbeit/index.html
Sascha Pscheidt: Ein Lernprogramm zur Spracherkennung mit Neuronalen Netzen
http://fbim.fh-regensburg.de/~saj39122/pscheidt/diplomarbeit/index.html
Peter Engl / Christian Peter: Fingerabdruckerkennung als Anwendung neuronaler Netze
http://fbim.fh-regensburg.de/~saj39122/pengl/diplomarbeit/index.html
Christian Miklos: Support Vector Machines in der digitalen Mustererkennung
http://fbim.fh-regensburg.de/~saj39122/Diplomarbeiten/Miklos/
Valentina Stellwag: Steuerung eines mobilen Roboters mit Hilfe von Neuronalen Netzen
http://fbim.fh-regensburg.de/~saj39122/Diplomarbeiten/ValentinaStellwag/index.html
7
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
1. Grundlagen
1.1 Einführung
1.1.1 Biologische bzw. psychologische Grundlagen
Grundidee
Angelehnt an Anatomie und Physiologie des menschlichen Gehirns entspricht ein
"Neuronales Netz (NN)" einer großen Menge sehr einfacher Prozessoren
(Neuronen), die vielfach (ein Neuron bspw. mit bis zu 10.000 weiteren Neuronen)
verbunden sind.
Aufbau eines Neurons
Zellkörper, Axon, Dendriten, Synapsen1
Arbeitsweise
Über die verbindenden Synapsen (Kontaktstellen, Speicher) können Signale
verstärkt oder vermindert (d.h. gewichtet) weitergegeben werden. Falls das
Summensignal einen bestimmten Wert überschreitet, reagiert das einzelne Neuron
mit einem Signal (Prozessorbefehl).
Zwei unterschiedliche Funktionsebenen sind zu beachten:
- Die schnelle Ebene (Veränderungen im Sekundenbereich) ist durch den
augenblicklichen Aktivitätsbestand geprägt (Kurzzeitgedächtnis)
- Die 2. Ebene ist durch allmähliche Änderungen des Verbindungsmusters der
schnellen Aktivitätsmuster geprägt (Langzeitgedächtnis)
Neuronenaktivitäten und Synapsenstärken bestimmen die Arbeitsweise des Gehirns.
1
vgl. Abb. 1.1-1
8
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
1.1.2 Überführung in ein datentechnisches Verarbeitungsmodell (NN)
Strukturelemente eines Neurons werden in ein datentechnisches Verarbeitungsmodell überführt. Dabei dient (bzw. dienen):
- der Zellkörper als Informationsträger. Im einfachsten Fall werden 2 Zustände
(erregt, nicht erregt) unterschieden
- die Dendriten zur Aufsummierung der Netzeingaben
- das Axon zur Weitervermittlung des Erregungszustands und Kontaktaufnahme mit
den Dendriten nachfolgender Neuronen über Synapsen.
- die Synapse zur Bestimmung, wie sich die über ein Axon vermittelte Erregung auf
andere Zellen auswirken soll. Die Stärke der Synapsen wird meistens durch einen
numerischen Wert (dem Verbindungsgewicht) dargestellt.
Dendriten
Dendriten
Zellkern
Zellkörper
Dendriten
Dendriten
Synaptische Endköpfe
Nervernfaser
(Axon)
Abb. 1.1-1: Aufbau einer Nervenzelle
Das menschliche Gehirn ist jedoch kein autonomes Gebilde. Es benötigt
- Rezeptoren als Informatiomationsträger
- Effektoren zur Ausgabe
Die NN vorgeschaltete Ansteuerung wird als Eingabecodierung, die
nachgeschaltete Ausgabe als Ausgabecodierung bezeichnet.
Eingabecodierung heißt: Die Fragen, den Sachverhalt, das Problem der
Anwendung (entsprechend den Netztypkonventionen) zu verschlüsseln
Die Reaktion des Netzes ist dann wieder zu einer Antwort, einer Beurteilung oder
einer Lösung zu dekodieren.
NN versuchen in Struktur und Funktionsweise Gehirnkomplexe nachzubilden und
dadurch eine Simulation menschlicher Denkvorgänge zu erreichen.
9
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
1.2 Wie arbeiten Neuronale Netzwerke?
1.2.1 Ein einführendes Beispiel
Beschreibung der Aufgabe: Ein Student der Fachhochschule Regensburg steht vor
der
folgenden
Situation:
Wieder
einmal
drohen
die
lästigen
Semesterabschlußprüfungen. Das hebt nicht gerade sein augenblickliches
Stimmungstief, denn der Vorlesungsbesuch war mäßig, und die Übungen und
Ausarbeitungen zum Vorlesungsstoff hat er nicht richtig verstanden. Es ist zu
befürchten, daß er die Prüfung nicht schafft. Zum Stimmungstief kommt hinzu, daß
der Vater des Studenten für eine gute Prüfung die Finanzierung einer Urlaubsreise
zu den Malediven (Schwimmen, Tauchen) in Aussicht gestellt hat, die er angesichts
seiner Lage abschreiben kann.
Ein einfaches Modell eines neuronalen Netzes soll die möglichen Zusammenhänge
zwischen dem Prüfungsvorbereitungen und den Handlungen bzw. Stimmungslagen
einer Person beschreiben.
Modellbeschreibung: Das Modell besteht aus 2 Schichten, der Eingabe- und
Ausgabeschicht. Nur die Elemente der Eingabeschicht nehmen Informationen auf,
nur die Elemente der Ausgabeschicht geben Informationen vom Modell an die
Außenwelt weiter. Jedes Element der Eingabeschicht ist mit jedem Element der
Ausgabeschicht verbunden. Ein einzelnes Element der Eingabe- und
Ausgabeschicht heißt Neuron bzw. Prozessorelement bzw. Verarbeitungseinheit
(Unit).
regelmäßiger
Vorlesungsbesuch
Erfolgreiche
Übungsteilnahme
Semester
Abschlußprüfung
Eingabeschicht
Ausgabeschicht
Schwimmen
Tauchen
Stimmungshoch
negative Prüfung
Abb. 1.2-2: Einfaches Modell eines NN
Die Informationsverarbeitung des Modells erfolgt schichtenweise von oben nach
unten.
Zur Vereinfachung wird festgelegt:
- aktiv entspricht dem Wert +1
- inaktiv entspricht dem Wert -1
Ein Testfall mit Kodierung der Eingabe kann für das vorliegende Beispiel somit
folgendermaßen dargestellt werden:
10
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
regelmäßiger
Vorlesungsbesuch
-1
Erfolgreiche
Übungsteilnahme
-1
Semester
Abschlußprüfung
+1
-1
-1
+1
Eingabeschicht
-1
-1
+1
Ausgabeschicht
-1
-1
+1
Schwimmen
Tauchen
Stimmungshoch
negative Prüfung
Abb. 1.2-3: Verarbeitungsmodell
Die Neuronen im vorliegenden Modell haben mindestens einen Eingang, der
Informationen aufnimmt und einen Ausgang, der das Ergebnis der vorliegenden
Verarbeitung der Eingangswerte beschreibt. Er kann den anderen Neuronen in darüberliegenden Schichten als Eingangswert dienen.
Trainingsphase
1. Schritt: Einfaches Aufsummieren der Eingangswerte
kein
regelmäßiger
Vorlesungsbesuch
keine
erfolgreiche
Übungsteilnahme
Semester
Abschlußprüfung
-1
-1
+1
Eingaben
(+)
(+)
(+)
-1
-1
+1
Summe
Ergebnis
-1
-1
+1
-1
-1
(+)
(+)
-1
-1
+1
-1
-1
Eingabeschicht
+1 Eingaben
(+)
-1
Summe
Ergebnis
Ausgabeschicht
kein
kein
Schwimmen
Tauchen
Stimmungshoch
keine
negative Prüfung
Abb. 1.2-4: Einfaches Aufsummieren der Eingaben
11
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Das einfache Aufsummieren führt nicht zum gewünschten Ergebnis.
2. Schritt
- Verschieden starke Gewichtung der Eingänge (unterschiedliche Bewertung der Verbindungen)
- Aufsummieren
- Schwellwertabgleich (zur Bestimmung definierten Ausgangszustände)
Ein Modellneuron umfaßt somit:
Eingang/Eingang/...
Gewicht/Gewicht/...
Verarbeitung
Ergebnis
Ergebnis > Schwellwert
Eine mögliche Lösung ist dann:
Testfall:
kein
keine
Semester
regelmäßiger
erfolgreiche
Abschlußprüfung
Vorlesungsbesuch Übungsteilnahme
-1
Eingaben
Gewichte
-1
1
-1
0
Summe
-1
Schwellenwert
>0?
-1
1
0
-1
-1
0
+1
-1
1
1
0
-1
-1
0
-1
0
1
1
1
>0?
-1
>0?
1
Ergebnis
(nach Decodierung)
kein
Schwimmen, Tauchen
kein
Stimmungshoch
negative
Prüfung
Abb.1.2-5: Verarbeitung mit gewichteten Verbindungen
Das Modell liefert aber nicht nur Empfehlungen für die vor der Tür stehenden
Abschlußprüfungen,
sondern
auch
Reaktionen
auf
"regelmäßigen
Vorlesungsbesuch" (Schwimmen, Tauchen) bzw. auf "erfolgreiche Bearbeitung der
Übungen" ("Stimmungshoch"). Das Modell arbeitet aber nicht vollständig korrekt. So
müßte bei "regelmäßigem Vorlesungsbesuch" bzw. "erfolgreicher Bearbeitung der
12
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Übungen" zwar "Schwimmen, Tauchen" bzw. "Stimmungshoch" aktiv sein, aber
"schlechte Prüfung" inaktiv werden.
3. Schritt: Modifikation der Verbindungsstärken (Gewichte) über eine Lernregel
Neuronale Netze können lernen. Das Lernen geschieht durch Modifikation der
Verbindungsstärken nach einer vorgegebenen Lernregel:
Die Modifikation der Verbindungen soll hier auf einer Hypothese beruhen, die
besagt, daß die Verbindungen zwischen zwei Neuronen immer verstärkt wird, wenn
beide Neuronen gleichzeitig aktiv sind (Hebbsche Hypothese)2.
wij    ai  a j
a i : {-1,1} des Ausgabeneurons
a j : Aktivität {-1,1} des Eingabeneurons
 : Lernrate
Ausgangslage: Das Trainingsbeispiel umfaßt
Vorlesungsbesuch",
"keine
erfolgreiche
Semesterabschlußprüfung" (d.h. aktiv - inaktiv
"Schwimmen, Tauchen", "Stimmungshoch", "keine
aktiv - inaktiv).
Testfall:
die Eingabe "regelmäßigen
Übungsbearbeitung",
"keine
- inaktiv) und die Ausgabe
schlechte Prüfung" (d.h. aktiv -
keine
Semester
regelmäßiger
erfolgreiche
Abschlußprüfung
Vorlesungsbesuch Übungsteilnahme
1
Eingaben
Gewichte
1
1
Summe
-1
-1
0
-1
0
1
Schwellenwert
1
0
-1
-1
1
-1
0
-1
>0?
>0?
1
-1
1
0
-1 -1
0 1
-1
>0?
-1
Ergebnis
(nach Decodierung)
Schwimmen, Tauchen
kein
Stimmungshoch
Abb. 1.2-6: Verarbeitung mit gewichteten Verbindungen
2
Vgl. Skriptum 2.3.2.1
13
keine negative
Prüfung
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Anwendung der Hebbschen-Hypothese mit   1
1
Eingaben
Gewichte
1
2
Summe
Schwellenwert
-1
-1
-1
-1
-1
1
-1
-1
-1
2
-1
1
1
-1
-1
1
4
-4
-4
>0?
>0?
>0?
1
-1
-1
2
-1
Ergebnis
(nach Decodierung)
Schwimmen, Tauchen
kein
Stimmungshoch
keine negative
Prüfun
Abb. 1.2-7: Trainingsbeispiel nach Anwendung der Hebbschen Regel
Nach diesem Lernschritt mit Lernrate 1 haben Neuronen der Ausgabeschicht noch
immer nicht die gewünschte Aktivität (anstattt „kein Stimmungshoch“ ist
„Stimmungshoch“ gewünscht). Die Anwendung der Hebbschen Regel im Sinne
unüberwachten Lernens führt nicht zu dem gewünschten Ergebnis.
Es gibt bei der Hebb’schen Lernregel generell ein Problem: Bei anhaltenden
Aktivitäten beider Zellen wachsen die Gewichte ins Unendliche; die Zellen kennen
kein „Vergessen“. Somit ist die Hebb’sche Lernregel nicht realistisch. Durch
entsprechende Modifikationen läßt sich dieser Nachteil jedoch beseitigen.
4. Schritt: Modifikation der Gewichte mit Hilfe der sog. Delta-Regel3
wij     i  a j
 i  t i  ai (Fehler: gewünschter Zustand – tatsächlicher Zustand)
wijneu  wijalt  wij
Da hier ein neues Lernverfahren zur Anwendung kommt, muß das Training von
Anfang an wiederholt werden.
3
Vgl. Skriptum 2.3.2.3
14
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
1. Testfall:
kein
keine
Semester
regelmäßiger
erfolgreiche
Abschlußprüfung
Vorlesungsbesuch Übungsteilnahme
-1
Eingaben
Gewichte
-1
0
-1
-1
0
1
0
-1
0
1
-1
0
1
0
Summe
0
Schwellenwert
>0?
>0?
-1
-1
-1
0
0
-1 1
0 0
0
>0?
-1
Ergebnis
Abb. 1.2-8: Verarbeitung mit gewichteten Verbindungen
Der Fehler führt zu einer Modifikation der Gewichte:
ti
-1
-1
1
ai
-1
-1
-1
i
0
0
2
Mit   0.25 ergibt sich
aj
-1
-1
1
-1
-1
1
-1
-1
wij
0
0
0
0
0
0
-0.5 -0.5 0.5
Test:
Summe
Schwellenwert
0
>0
0
>0
-1
-1
15
1.5
>0
1
1
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Testfall:
keine
keine Semester
regelmäßiger
erfolgreiche
Abschlußprüfung
Vorlesungsbesuch Übungsteilnahme
1
Eingaben
Gewichte
1
0
-1
0
Summe
Schwellenwert
-1
-1
0
1
0
-1
-1
0
-1
0
1 -1
-1
-0.5 -0.5 0.5
0
0
-0.5
>0?
>0?
>0?
-1
-1
-1
Ergebnis
Abb.: Verarbeitung mit gewichteten Verbindungen
Der Fehler führt zu einer Modifikation der Gewichte:
ti
1
1
-1
ai
-1
-1
-1
i
2
2
0
Mit   0.25 ergibt sich
aj
wij
1
-1
-1
0.5 -0.5 -0.5
1
-1
-1
0.5 -0.5 -0.5
1
-1
-1
-0.5 -0.5 0.5
Test:
Summe
Schwellenwert
1.5
>0
1.5
>0
0.5
>0
1
1
1
Der Fehler wird nicht sofort weiter verfolgt. Es werden alle vorhandenen Muster erst
einmal bearbeitet (Trainingszyklus, Train ingsepochen).
 1 1 1 
 mit dem Ziel
Bisher wurden folgende Muster bearbeitet: P  
 1  1  1
 1 1 1 
 . Der Fehler nach einer Epoche wird
(gewünschtes Ergebnis) T  
 1 1  1
16
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
bestimmt durch
 (t
p
ip
 ai p ) 2 und führt hier auf den Wert 12. Dieser Fehler muß
i
auf eine vorgegebene Schranke reduziert werden können, d.h.: Das Training muß
solange wiederholt werden, bis die vorgegebene Fehlergröße unterschritten ist.
Im vorliegenden Fall wird das aber nur dann gelingen, wenn die Eingabevektoren
linear unabhängig4 sind.
1.2.2 Allgemeiner Aufbau neuronaler Netze
1. Grundlegende Bestandteile
Das neuronale Netz an sich gibt es nicht. Es gibt lediglich einige unterschiedliche
Modelle und Ansätze. Ein "künstliches neuronales Netz" besteht generell aus
verschiedenen Elementen, Strukturen, Regeln.
Die grundlegenden Bestandteile sind:
- eine Menge von Verarbeitungselementen (Neuronen)
- eine Menge von Aktivitätszuständen
- eine Ausgabefunktion für jedes Element
- eine Verbindungshierarchie
- eine Regel zur Fortschaltung (Propagierung) der Aktivitätsmuster von einem Element zum nächsten
- eine Regel zur Aktivierung eines Elements durch anliegende Signale und Erzeugung eines neuen
Aktivitätszustands
- einer Lernregel zur Modifizierung der Verbindungsgewichte
- eine Umgebung, in der das Netz arbeitet
Die Verarbeitung in solchen Netzwerken erfolgt in der Regel von der Eingabeschicht
über verborgene Schichten zur Ausgabeschicht, gelegentlich aber auch von der
Eingabeschicht direkt zur Ausgabeschicht oder in einem Feedback zwischen den
einzelnen Schichten (hin und her).
Input-Units
Hidden Units
Output-Units
Eingabeschicht
verborgene Schicht
Ausgabeschicht
Abb. 1.2-13: Schichtenweise Verarbeitung
Die einzelnen Schichten bestehen aus einer Anzahl von Prozessorelementen. Jede
Schicht enthält mindestens ein Prozessorelement. Elemente einer Schicht sind
meistens von der gleichen Art.
4
Vgl. Skriptum 1.2.4
17
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Ein Prozessorelement kann mit beliebig vielen anderen Prozessorelementen einer
anderen Schicht ("inter-neuronlayer-connection) verbunden sein oder auch mit
Prozessorelementen der gleichen Schicht (intra-neuronlayer-connection). Eine
Verbindung von Prozessorelementj nach Prozessorelementi heißt Gewicht, neben
variablen Gewichten gibt es auch feste Gewichte. Gewichte werden gewöhnlich
durch relle Zahlen (häufig im Intervall von -1 bis +1) dargestellt.
In vielen Fällen gibt es eine zusätzliche Schicht mit genau einem Element, das Bias
oder Schwellenwert genannt wird. Mathematisch gibt der Schwellenwert die Stelle
der größten Steigung einer monoton wachsenden Aktivierungsfunktion an. Biologisch
entspricht er der Reizschwelle, die erreicht werden muß, damit das Neuron „feuern“
kann. In einfachen Anwendungen hat dieses Element den konstanten Wert 1 und
hat nur Ausgänge keine Eingänge. Mit Hilfe des Bias-Elements kann sichergestellt
werden, dass bestimmte Prozessorelmente immer eine Eingabe ungleich Null
erhalten. In Simulationen kann dieser Schwellwert unterschiedlich realisiert werden,
entweder als Parameter in der Aktivierungsfunktion oder über einen zusätzlichen
gewichteten Eingang.
Verbindungen zwischen Neuronen der gleichen Schicht sind häufig sowohl
erregender als auch hemmender Art, während zwischen Schichten meistens nur
erregende Verbindungen bestehen. Falls sich die Aktivierung von Schicht zu Schicht
vorwärts ausbreitet, spricht man von Feedforward-Netzen. Es handelt sich um
Feedback-Netze, falls die Aktivierung von nachfolgenden Schichten auch an
vorgelagerte Schichten zurückgegeben wird.
2. Arbeitsweise der Elemente NN
Die Elemente (Neuronen) in Neuronalen Netze arbeiten nach einem konstanten
Schema. Es werden Eingabemuster i verarbeitet, die Vektoren aus Zahlen (i1,i2, ...
in) sind. Über die Verbindungshierarchie, die Verbindungsgewichte bzw. die
Aktivierungsfunktion wird jedes Eingabemuster durch das Netz geschleußt, bis neu
errechnete (Aktivitäts-)Werte an den Ausgangsneuronen erscheinen. Auch die
Ausgangswerte können wieder als Zahlenvektor o = (o1,o2,...,om) geschrieben oder
zu einem Muster zusammengefaßt werden.
18
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
von Neuron j
o1 o2 o3
...........
on
i1 i2 i3
...........
in
o1 o2 o3
............
om
Neuron i
von Neuron i
Abb. 1.2-14: Aufbau eines Neurons
Zunächst werden alle Eingänge mit einer Eingabefunktion (Input) bearbeitet. Über
die an einem Neuron einlaufenden Verbindungen werden Aktivierungen von anderen
Neuronen herbeigeführt (z.B. o1, o2, o3, ... ). Die Aktivierungen müssen den
Übertragungswiderstand (das Gewicht der Verbindung zwischen zwei Neuronen)
überwinden. Gewöhnlich ist das ein einfaches Aufsummieren der Ein-gänge oj
multipliziert mit den entsprechenden Gewichten wij:
neti   o j wij
j
Diese
Formel
ist
auch
unter
dem
Namen
Ausbreitungsregel
(Propagierungsfunktion) bekannt, denn sie beschreibt die Signalweiterleitung
durch das Netz.
Das Ergebnis dieser Funktion wird an die sogenannte Aktivierungsfunktion
(Transferfunktion, Schwellwertfunktion) weitergeleitet. Die Transferfunktion legt die
Aktivität fest, die ein Prozessorelement in Abhängigkeit von der aktuellen Eingabe
annehmen soll.
Der Aktivierungswert einer Verarbeitungseinheit wird über die Funktion a i(t)
bestimmt. Häufig ist sie die identische Abbildung vom Netto-Input (ai = neti).
Allgemein ist sie von vorhergehenden Aktivierungen, einem Satz von Parametern
und einem Aktivierungszufluß von außen (ext_inpi) abhängig:
ai (t  1)  Fi (neti (t  1), ext _ inpi (t  1), ai (t ))
Mit den Aktivierungsgrößen Nettoinput, externer Input und alter Aktivierungszustand
kann der neue Aktivierungszustand ai des Neurons i unter Anwendung der
Aktivierungsfunktion F bestimmt werden.
Als Aktivierungsfunktion kommen häufig die lineare Funktion, Schwellwertfunktionen
oder Sigmoidfunktionen zum Einsatz.
19
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
o1
o2
wi1 wi2
o3.....
wi3
Propagierungsfunktion
Aktivierungsfunktion
Ausgabefunktion
oi
Abb. 1.2-15: Verarbeitungsfunktionen in einem Neuron
Die Ausgabefunktion (Output) kann der Aktivierungsfunktion nachgeschaltet sein.
Die Outputfunktion definiert, welches Ausgabesignal an die benachbarten Einheiten
weitergegeben werden soll:
oi (t )  f i (ai (t ))
In der Regel wird der Ausgangszustand dem inneren Aktivierungszustand
gleichgesetzt, aber in einigen Fällen hängt z. B. die Wahrscheinlichkeit, daß der
Ausgabewert 0 oder 1 ist, vom inneren Aktivierungszustand ab.
Die Outputfunktion ermöglicht einen Wettbewerb unter den einzelnen
Prozessorelementen einer Schicht. So kann z.B. die Outputfunktion "winner-take-all"
gewählt werden. In diesem Fall gibt nur das Prozessorelement einer Schicht seine
Information weiter, dessen Transferfunktion den höchsten Wert liefert. Alle anderen
Prozessorelemente dieser Schicht geben eine Null weiter.
Häufig beschränkt man sich bei der Beschreibung des Prozessor- Elements auf
folgende Aktivierungsfunktion:
ai (t )  Fi (neti (t ))
Der Wert des Aktivitätssignals ist hier nicht mehr vom vorangegangenen Wert
abhängig, und das Ausgangssignal ist gleich dem Aktivitätssignal.
20
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3. Zusammenstellung der wesentlichen Aktivierungsfunktionen
Besondere Bedeutung kommt der Aktivierungsfunktion Fi (neti (t )) zu. Durch
geeignete Wahl läßt sich jede gewünschte nichtlineare Kennlinie realisieren.
3.1 Lineare Funktion
Fi (neti (t ))
net i (t )
Abb.: 1.2-16: Lineare Aktivierungsfunktion
3.2 halblineare Funktion
Fi (neti (t ))
net i (t )

Fi (net i (t ))  
0
x
x 
Abb. 1.2-16: Halblineare Aktivierungsfunktion:
21
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.3 Linear bis zur Sättigung (linear threshold)
Fi (neti (t ))
1.0
net i (t )
-1.0
-0.5
0.5
1.0
Abb.: 1.2-17: Lineare Aktivierungsfunktion
3.4 Schwellenwertfunktion (threshold)
Fi (neti (t ))
1.0
net i (t )
-1.0
-0.5
0.5
1.0
Abb. 1.2-18: Schwellenwertfunktion:
bzw.
Fi (neti (t ))
1.0
-1.0
-0.5
0
x
1
x
Fi (net i (t ))  
net i (t )

1.0
Abb. 1.2-19: Schwellenwertfunktion.
22
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.5 Signum-Funktion (bipolare Schwellenwertfunktion)
Fi (neti (t ))
1.0
-1.0
net i (t )

-0.5
1.0
-1.0
Fi (net i (t ))  
-1
1
x
x
Abb. 1.2-20: Schwellenwertfunktion.
3.6 Sigmoid-Funktion
Fi (neti (t ))
net i (t )
Fi (net i (t )) 
1
1  e  neti (t )
Abb. 1.2-21: Sigmoid-Funktion
23
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Beispiel
Durch geeignete Wahl der Gewichtsfaktoren wi1(t), wi2(t) und der Schwelle  (in
Verbindung mit der Schwellenwertfunktion) lassen sich die logischen Grundoperationen , ,  abbilden.
log. Funktion



wi1(t)
1
1
-1
wi2(t)
1
1
0

1.5
0.5
-0.5
1.2.3 Informationsverarbeitung in neuronalen Netzen
Sie bedeutet in vielen Fällen: Abbildung von Mustern.
Über die Eingabeschicht werden die im Eingabemuster enthaltenen Informationen in
das Netz eingespeist. Aus der Ausgabeschicht kann das nach Ausbreitung von
Aktivierungen im Netzwerk entstehende Ausgabemuster abgelesen werden.
Ein neuronales Netzwerk arbeitet gewöhnlich in zwei verschiedenen Modi
- einem Lernmodus
- einem Ausführungsmodus (Recall Modus)
1. Lernmodus (Trainingsphase)
Lernen bedeutet Verändern der Gewichte. In der Regel werden Gewichte solange
verändert, bis die Zuordnung der Eingabemuster zu einer gewünschten Ausgabe
erreicht wurde. Das Verändern der Gewichte geschieht über Lernregeln.
Einfache Lernregeln sind die bereits bekannte Lernregel von Hebb und die
erweiterte Delta-Lernregel von Widrow/Hoff. Die einfachste Form der Hebb-Regel
ist:
wij    ai  o j
"  " ist hier Parameter, der die Größe eines Lernschritts bemißt. "  " wird
günstigerweise zwischen 0 und 1 gewählt. Ist  = 0, dann wird nichts gelernt. Ist  =
1, dann werden die Gewichte, die schon vorher erlernte Muster assoziieren konnten,
wahrscheinlich zerstört, d.h.: Das Netzwerk merkt sich neue Muster so stark, daß die
alten Muster teilweise zerstört werden.
Eine andere sehr häufig verwendete Form des Lernens ist die sog. Delta-Regel:
wij    ( ti  oi )  o j
bzw.
wij     i  o j
wij : Änderung des Gewichts von Verarbeitungseinheit j zu Verarbeitungseinheit i in
einem Lernschritt.
24
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
ti (target): gewünschter Output der Unit i
oi: tatsächlicher Output der Verarbeitungseinheit i
oj: Output der Verarbeitungseinheit j
i  ti  oi : Fehlersignal der Verarbeitungseinheit i
Diese Lernregel, auch als Widrow/Hoff-Regel (1960) bekannt, ermöglicht es,
Gewichtsänderungen so durchzuführen, daß ein bestimmter Eingabevektor mit
einem gewünschten Ausgabevektor assoziiert wird. Allerdings ist sie nur für
zweischichtige Netze definiert, da der gewünschte Output nur im Output-Layer, nicht
aber für Hidden-Units beschrieben wird. Eine für mehrere Schichten geeignete
Variante
ist
das
sogenannte
Back-Propagation-Lernverfahren,
eine
Verallgemeinerung der Delta-Regel, die eine Berechnung der Fehlersignale für
Hidden-Units definiert. Bei der Delta-Lernregel wird der Fehler nach der
tatsächlichen Ausgabe eines Prozessorelements der Ausgabeschicht (bzw. seiner
Aktivität) und dem vorgegebenen Ausgabewert berechnet. Dieser Fehler wird
gleichmäßig auf die verschiedenen Gewichte der Prozessorelemente verteilt, die
Gewichte werden angepaßt. Das Lernen muß solange andauern, bis die
Veränderung der Gewichte gegen Null geht.
Man gibt sich offenbar mit dem errechneten Ausgangsmuster zufrieden und
berechnet den Ausgangsfehler als Differenz zwischen Ist- und Sollausgang t (Target:
Ziel) des Netzes und speist ihn rückwärts wieder in das Netz ein. Mit Hilfe der
Lernregeln werden die Verbindungsgewichte so verbessert, daß der Ausgangsfehler
des Netzes in der nächsten Ausführungsphase (Recall-) geringer wird.
Recall- und Lernphase wechseln sich gegenseitig so lange ab, bis der
Ausgangsfehler für alle zu erlernenden Muster unter eine vorgegebene Schwelle
sinkt.
2. Ausführungsmodus
In diesem Modus werden trainierten Netzwerken Eingabedaten präsentiert, die sie
noch nicht gelernt haben. Ein neuronales Netz, das nur wenige Lernschritte
durchgeführt hat, produziert einen anderen Ausgabewert als ein Netz, das genügend
lange gelernt hat. Die Qualität des Ausgabevektors hängt entscheidend von der
Länge und der Qualität der vorangegangenen Lernphase ab.
Man unterscheidet bzgl. der beiden Lernregeln
- das überwachte Lernen (Delta-Regel)
- das unüberwachte Lernen (Hebbsche Regel)
Beim überwachten Lernen ist zusätzlich eine weitere Unterteilung in
mit Lehrer bzw. ohne Lehrer
möglich. Das überwachte Lernen mit Lehrer bietet dem Netzwerk zum Vergleich die
richtige Lösung an. Tritt anstelle des Lehrers der Bewerter, so wird dem Netzwerk
lediglich nur noch Information über die Qualität des Ergebnisses angeboten.
Das unüberwachte Lernen benötigt weder Lehrer noch Bewerter. Der Abgleich der
Gewichtsfaktoren kannn nach der Hebbschen Regel erfolgen. In diesem Fall spricht
man auch von selbstorganisierenden Netzwerken.
25
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
1.2.4 Mathematische Grundlagen zum Lernverhalten NN
Beim Lernen muß ein Netzwerk über die jeweilige Lernregel Gewichte finden, die bei
vorgegebener Eingabe die erwünschte Ausgabe erzeugen. Das Lernverhalten NN
kann mit Matrizen und Vektoren beschrieben werden. Ist ein Eingabevektor i (in
normierter Darstellung5) und ein Ausgabevektor o gegeben, so muß das Netzwerk
eine Gewichtsmatrix finden, die die Gleichung
o  Wi
erfüllt.
Im einfachsten Fall besteht o nur aus einer Komponente, die Gewichtsmatrix
besteht dann nur aus einer Zeile, und es gilt o  w  i
Falls i  1 ist, dann ist auch das Skalarprodukt i T  i vom Wert 1.
o  iT  w  i  iT  w  iT  i 6
o  iT  w
Dieser Ansatz läßt sich verallgemeinern: W  o  i T
Wird die Gewichtsmatrix mit dem Eingabevektor multipliziert, dann ergibt sich der
gewünschte Ausgabevektor:




W  i  oi  i T  i  o  i T  i  o
Falls man für die Eingabevektoren noch eine Reihe zusätzlicher Eigenschaften
fordert, dann kann man eine einzige Matrix konstruieren, die gleichzeitig mehrere
verschiedene Eingabe- und Ausgabevektoren aufeinander abbildet.
Solche Eigenschaften für alle Eingabevektoren sind:
- ii  i j  0
für alle i <> j (d.h. die Eingabevektoren sind orthogonal zueinander)
- i i 1
- i 1
T
Dann gilt für die Matrix
M   W   o  iT
i
i
folgendes
 







 
T

 
T

M  i j   Wi  i j   ( o i  i i )  i j   oi  i i  i j   oi  ( ii  i j )  o j  ( i j  i j )  o j
i
T
i
i

5
Der Vektor

T
i

x  ( x1 , x2 ,..., xn ) mit dem Betrag x  x12  x22 ... xn2 ist in normierter Darstellung:




x N  ( x1 / x , x2 / x ,...., xn / x ) . x N hat dann den Wert 1.
6
Das Skalarprodukt ist kommutativ
26
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Die Matrix kann also beliebige Ein- und Ausgabevektoren einander zuordnen.
Allerdings müssen die Eingabevektoren dann orthogonal zueinander sein. In diesem
Fall ist die vorliegende Konstruktion eine Rechtfertigung für die Hebbsche Regel.
Sind die Eingabevektoren nicht orthogonal zueinander, sondern bspw. linear 7
unabhängig, dann muß zur Konstruktion der Gewichtsmatrix ein anderer
Lernalgorithmus herangezogen werden (z.B. Delta-Regel).
Eine lineare Abhängigkeit von Vektoren erschwert die Konstruktion von
Gewichtsmatrizen und spielt eine entscheidende Rolle beim Trainieren (Lernen)
Neuronaler Netze.
Mathematisch gesehen bilden NN Vektoren auf andere Vektoren ab. Ein NN ordnet
verschiedenen Eingabevektoren entsprechende Ausgabevektoren zu. Was das NN
mit den Vektoren anstellt (addiert, multipliziert, transformiert), das ist der eigentliche
Kern eines neuronalen Netzes. Hier setzen die zahlreichen Modelle an.
1.2.5 Implementierung NN
Wünschenswert wäre, Chips zu haben, die neuronale Zellen - in Analogie zu
biologischen Gehirnen - auf Hardware-Ebene abbilden.
Dann könnte man eine große Anzahl solcher Bausteine zu Netzen verschalten und
hätte ein leistungsfähiges Werkzeug zur Simulation NN. Zwar soll es bereits 100
verschiedene Chip-Designs geben, aber nur wenige davon sind als kommerzielle
Produkte verfügbar. Man benutzt daher Software-Simulatoren auf herkömmlichen
Rechnern. Für manche Produkte gibt es bereits Beschleunigungskarten mit
Spezialprozessoren für schnelle Trainingsläufe und Netzwerk- Compiler, die
spezielle künstliche NN (KNN) auf diese Beschleunigerkarten umsetzen. Fertige CProgramme (auf beigefügter Diskette) und entsprechendes Hintergrundwissen
enthält das Buch von Rumelhart 8. Es ist die Basis für viele Software-Simulatoren.


7



v 0 ist eine Linearkombination der Vektoren v 1 , v 2 ,..., v n , falls es gewisse Koeffizienten gibt, so daß



v 0  a1  v 1  a2  v 2 ...  an  vn gilt.

v 0 kann also aus der Addition bestimmter Vielfache oder Teile der anderen Vektoren bestimmt werden.


Eine Menge von Vektoren { vi |i < n} heißt linear unabhängig, falls keiner der Vektoren vi als Linearkombination
anderer Vektoren dargestellet werden kann
8 vgl. Rumelhart, David E. und McClelland, James L.: Parallel Distributed Processing in the Microstructure of
Cognition, MIT Press (1986)
27
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Wichtige Ausprägungen NN
2.1 Modellierung Neuraler Netze
2.1.1 Übersicht
Im Laufe eines Zeitraums von 40 Jahren (1950-1990) wurde eine große Anzahl NN
entwickelt. Diese Netze unterscheiden sich in mehrfacher Hinsicht, z. B. durch
- die Anzahl der Schichten
- die Art des Lernens
- feed forward bzw. feed back
- Annahme binärer oder stetiger Ereignisse
Eine einfache Klassifizierung könnte bspw. folgendermaßen aussehen:
feed forward
einlagig, binär
Perzeptron
feed back
mehrlagig
BPG
deterministisch
CPN
selbstorganis.
Boltzmann-Maschine
BSB, Hopfield
BPG: Backproppagation
CPN: Counterpropagation
BAM: Bidirectional Associative Memory
ART: Adaptive Resonance Theory
Abb. 2.1-1: Klassifizierungsmerkmale NN
Die verschiedenen Netzwerktypen wurden z.T. mit sehr unterschiedlichen
Motivationen und Zielsetzungen entwickelt. Ein Teil der Netze wurde bspw. durch
physikalische Modelle inspiriert. Andere Netzwerke haben eher biologische
Grundlagen. Häufig war bei der Entwicklung des Netzwerks eine befriedigende
Antwort nach einer geeigneten Lernregel entscheidend.
Ein wichtiger Gesichtspunkt ist jeweils der lokale Charakter einer Lernregel. Ein
Neuron sollte nur aufgrund der ihm tatsächlich zur Verfügung stehenden Information
(Eingaben, eigene Aktivität und Ausgabe, evtl. lokal berechneter Fehler) seine
Gewichte anpassen. Nur ein solches Modell dient dem Verständnis der verteilten,
parallelen Verarbeitung von Daten im Gehirn und damit den biologischen Vorbild.
28
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.1.2 Topologien
2.1.2.1 Definition NN
Verbindet man mehrere Neuronen miteinander, dann erhält man ein Neuronales
Netz.
Ein Neuronales Netz ist ein Paar (N, V) mit einer Menge N von Neuronen und einer
Menge V von Verbindungen. Es umfasst den Aufbau eines gewichteten Graphen, für
die folgende Einschränkungen und Zusätze gelten:
1. Die Knoten des Graphen sind die Neuronen.
2. Die Kanten sind die Verbindungen.
3. Jedes Neuron kann eine beliebige Menge von Verbindungen empfangen, über die
das Neuron seine Eingaben erhält.
4. Jedes Neuron kann genau eine Ausgabe über eine beliebige Menge von
Verbindungen aussenden.
5. Das Neuronale Netz (NN) erhält aus Verbindungen, die der „Außenwelt“
entspringen, Eingaben und gibt seine Ausgaben über in der „Außenwelt“ endende
Verbindungen ab.
x1
x2
x3
xn
Eingabevektoren
……………
……………
.......................
.........
Eingabeschicht (Schicht 0)
1. verborgene Schicht
(h-2). verborgene Schicht
Ausgabeschicht (Schicht h)
Abb. 2.1-2: Darstellung eines „h“ Schichten umfassenden NN mit einer Eingabeschicht, „h-2“ verborgenen
Schichten und einer Ausgabeschicht (ohne Rückkopplungen)
Die Verbindungsstruktur (Topologie) kann man in Form einer Matrix beschreiben.
Zeilen und Spalten identifiziert man mit den Neuronen (Units, Zellen), in den
Kreuzingspunkt schreibt man das Gewicht der Verbindung. Für die Matrix gilt dann
bspw.
wij  0 : Keine Verbindung von Neuron „i“ zu Neuron „j“
wij  0 : hemmende Verbindung der Stärke wij
wij  0 : anregende Verbindung der Stärke wij
29
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.1.2.2 Netze ohne Rückkopplung, „feedforward“-Netze
1. Ebenenweise verbundene Feedforward-Netze
Die Netze sind in mehreren Ebenen (Schichten) eingeteilt. Es gibt nur Verbindungen
von einer Schicht zur nächsten (vgl. Abb. 2.1-2).
2. Feedforward-Netze mit „shortcut connections“
Bei diesen Netzen gibt es neben Verbindungen zwischen aufeinanderfolgenden
Ebenen auch solche, die Ebenen überspringen, d.h. die direkt von einem Neuron der
Ebene „k“ zu einem Neuron in Ebene „k+i“ mit „i > 1“ verlaufen.
„shortcut“
Abb. 2.1-3: Feedforward-Netz mit „shortcut“
2.1.2.3 Netze mit Rückkopplungen, „rekurrente Netze“
Netze mit Rückkopplungen unterteilt man in die Klasse der
1. Netze mit direkten Rückkopplungen („direct feedback“)
Die Netze ermöglichen es, dass ein Neuron seine eigene Aktivierung üner eine
Verbindung von seinem Ausgang zu seinem Eingang verstärkt oder abschwächt.
Diese Verbindungen bewirken oft, dass Neuronen die Grenzzustände ihrer
Aktivierungen annehmen, weil sie sich selbst verstärken oder hemmen.
2. Netze mit indirekten Rückkopplungen („indirect feedback“)
Bei diesen Netzen gibt es ein Rückkopplung von Neuronen höherer Ebenen zu
Neuronen niederer Ebenen. Diese Art der Rückkopplung macht auf bestimmte
Bereiche der Eingabeneuronen bzw. auf bestimmte Eingabemerkmale
aufmerksam.
3. Netze mit Rückkopplungen innerhalb einer Schicht („lateral feedback“)
Netze mit Rückkopplungen innerhalb derselben Schicht werden für Aufgaben
eingesetzt, bei denen nur ein Neuron in einer Gruppe von Neuronen aktiv werden
soll. Jedes Neuron erhält dann hemmende Verbindungen zu anderen Neuronen
und auch noch eine aktivierende direkte Rückkopplung zu sich selbst. Das Neuron
mit der stärksten Verbindung hemmt dann die anderen Neuronen
4. vollständig verbundene Netze.
30
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Vollständig verbundene Netze haben Verbindungen zwischen alle Neuronen. Sie
sind insbesondere durch die Hopfield-Netze (vgl. 2.7.1) weit verbreitet worden.
Netze mit Rückkopplungen werden auch für die Modellierung von Zeitabhängigkeiten
bei Daten (z.B. die Struktur einer Schwingung) eingesetzt.
2.2 Interaktive Netzwerke
Das interaktive Netzwerk soll zeigen, wie unterschiedliche, an verschiedenen
Stellen gespeicherte, inhaltlich zusammengehörige Informationen nach einem von
außen gegebenen Anstoß zusammengeführt werden können.
Interaktive Netzwerke zählen zur einfachsten Klasse NN und werden nicht trainiert.
Sie sind bspw. für die Simulation menschlicher Informationsvorgänge innerhalb der
Kognitionswissenschaft (Psychologie, KI-Forschung) interessant. Der Grund hierfür
liegt in dem Verhalten, das solche Netzwerkarchitekturen als Folge externer
Anregung zeigen, Bevor sich nämlich ein stabiler Zustand der AktivierungsVerteilung einstellt, wird eine dynamische Phase stetiger Veränderung durchlaufen.
Solche Übergangszustände lassen sich auch bei der menschlichen
Informationsverarbeitung (z.B. beim Verstehen der Sprache) 9 finden.
2.2.1 Beschreibung
2.2.1.1 Arbeitseinheiten
Ein "interactive and competetion"-Netzwerk besteht aus einer Anzahl
Arbeitseinheiten, die in Gruppen zusammengefaßt sind. Es gibt verstärkende
Verbindungen zwischen heterogenen Gruppen und hemmende Verbindungen
innerhalb der Einheiten einer Gruppe. Verstärkende Verbindungen wirken
grundsäzlich in beiden Richtungen, d.h. die Einheiten der heterogenen Gruppen
beeinflussen sich wechselseitig. Innerhalb einer Gruppe hemmen sich die Einheiten
wechselseitig. Daraus resultiert eine Art Wettbewerb. Die Einheiten, die am stärksten
aktiviert werden, versuchen die Aktivitäten der anderen Einheiten zu senken.
Es gibt zwei Klassen von Einheiten (units):
- Einheiten, die direkt Eingaben von außerhalb des Netzwerks empfangen können
(sichtbare Einheiten)
- Einheiten, die nicht direkt Eingaben von außerhalb des Netzwerks empfangen
können (verborgene Einheiten)
Der Benutzer kann Eingabemuster auf sichtbare Einheiten beziehen, es ist aber
nicht möglich, die verborgenen Einheiten anzusprechen. Deren Netzeingabe beruht
auf den Eingaben anderer Einheiten, mit denen sie in Verbindung stehen.
Bsp.: Gegeben ist die folgende relationale Datenbank
9
vgl. Hinweise in Kruse, Holger u.a.: Programmieren Neuronaler Netze, Addison-Wesley, Bonn1991, S.72
31
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Name
Bernd
Fritz
Doris
Hans
Josef
Kai
Rita
Theo
Uli
Anna
Liesel
Karl
Maria
Otto
Udo
Uwe
Willi
Bereich
T
T
T
T
T
T
T
T
T
W
W
W
W
W
W
W
W
Alter
20er
20er
20er
30er
20er
30er
20er
20er
30er
20er
20er
30er
20er
20er
20er
30er
20er
Bildung
FOS
FOS
HS
FOS
FOS
HS
HS
FOS
FOS
HS
FOS
HS
FOS
HS
HS
FOS
FOS
Schwerpunkt
SY
KI
KI
SY
SY
SY
KI
GR
GR
GR
SY
SY
KI
GR
KI
GR
SY
In der relationalen Datenbank sind die Daten in einer Tabelle konzentriert
gespeichert, im NN sind die Informationen (, wie das auch im Vorbild dem
menschlichen Gehirn der Fall ist,) verteilt. Die folgende Abbildung zeigt für einige
Individuen die Verteilung der Einheiten des NN.
Namen
Alter
Bernd
20er
Doris
Anna
30er
Fritz
Liesel
Schwerpunkt
KI
SY
GR
Bildung
Bereich
HS
FOS
T
W
Abb. 2.2-1: IAC zur Beispieldatenbank
32
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Jeder Bereich enthält die zugehörige Information, z.B. unter "Name" befinden sich
die Individuen: Bernd, Fritz, Doris. Die Einheiten in den einfach gerahmten Bereichen
sind sichtbar, sie können von außen angesprochen werden. Die im doppelt
gerahmten Kasten befindlichen Einheiten sind nach außen verborgen. Es handelt
sich hier um Instanzen.
2.2.1.2 Netzarchitektur
Für die Abbildung des Netzes in ein (Pascal-) Rechnerprogramm ist folgende
Konstante "Netz" vorgesehen:
const Dim
= 43;
U = 1.0; D = 1.0; V = -1.0; H = -1.0; Z = 0.0;
type
Vektor = array[1..Dim] of real;
Matrix = array[1..Dim,1..Dim] of real;
const Netz
: array[1..Dim] of Vektor =
(* 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 *)
((Z,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,D,D,D,D,D,D,D,D,Z,Z,Z,Z,Z,Z,Z,Z),
(V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,D,D,D,D,D,D,D),
(Z,Z,Z,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,D,D,Z,D,Z,D,D,Z,D,D,Z,D,D,D,Z,D),
(Z,Z,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,D,Z,Z,D,Z,Z,D,Z,Z,Z,D,Z),
(Z,Z,Z,Z,Z,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,D,Z,D,D,Z,Z,D,D,Z,D,Z,D,Z,Z,D,D),
(Z,Z,Z,Z,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,D,D,Z,Z,D,Z,D,Z,D,D,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,D,D,D,Z,Z,Z,Z,D,D,Z,Z,Z,Z,D),
(Z,Z,Z,Z,Z,Z,V,Z,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,D,Z,Z,Z,D,Z,Z,Z,Z,Z,D,Z,D,Z,Z),
(Z,Z,Z,Z,Z,Z,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,D,D,Z,Z,Z,D,Z,D,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,V,V,V,V,V,V,V,D,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,Z,V,V,V,V,V,V,V,V,V,V,V,V,V,V,V,Z,D,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,Z,V,V,V,V,V,V,V,V,V,V,V,V,V,V,Z,Z,D,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,Z,V,V,V,V,V,V,V,V,V,V,V,V,V,Z,Z,Z,D,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,Z,V,V,V,V,V,V,V,V,V,V,V,V,Z,Z,Z,Z,D,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,Z,V,V,V,V,V,V,V,V,V,V,V,Z,Z,Z,Z,Z,D,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,Z,V,V,V,V,V,V,V,V,V,V,Z,Z,Z,Z,Z,Z,D,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,Z,V,V,V,V,V,V,V,V,V,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,Z,V,V,V,V,V,V,V,V,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,Z,V,V,V,V,V,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,V,Z,V,V,V,V,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,V,V,Z,V,V,V,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,V,V,V,Z,V,V,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,V,V,V,V,Z,V,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,V,V,V,V,V,Z,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,V,V,V,V,V,V,Z,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D,Z),
(Z,Z,Z,Z,Z,Z,Z,Z,Z,V,V,V,V,V,V,V,V,V,V,V,V,V,V,V,V,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,D),
(U,Z,U,Z,U,Z,U,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H),
(U,Z,U,Z,U,Z,Z,U,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,H,Z,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H),
(U,Z,U,Z,Z,U,Z,U,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,H,H,Z,H,H,H,H,H,H,H,H,H,H,H,H,H,H),
(U,Z,Z,U,U,Z,U,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,H,H,H,Z,H,H,H,H,H,H,H,H,H,H,H,H,H),
(U,Z,U,Z,U,Z,U,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,H,H,H,H,Z,H,H,H,H,H,H,H,H,H,H,H,H),
(U,Z,Z,U,Z,U,U,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,H,H,H,H,H,Z,H,H,H,H,H,H,H,H,H,H,H),
(U,Z,U,Z,Z,U,Z,U,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,H,H,H,H,H,H,Z,H,H,H,H,H,H,H,H,H,H),
(U,Z,U,Z,U,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,H,H,H,H,H,H,H,Z,H,H,H,H,H,H,H,H,H),
(U,Z,Z,U,U,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,H,H,H,H,H,H,H,H,Z,H,H,H,H,H,H,H,H),
(Z,U,U,Z,Z,U,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,H,H,H,H,H,H,H,H,H,Z,H,H,H,H,H,H,H),
(Z,U,U,Z,U,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,Z,H,H,H,H,H,H,H,H,H,H,Z,H,H,H,H,H,H),
(Z,U,Z,U,Z,U,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,Z,H,H,H,H,H,H,H,H,H,H,H,Z,H,H,H,H,H),
(Z,U,U,Z,Z,U,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,Z,H,H,H,H,H,H,H,H,H,H,H,H,Z,H,H,H,H),
(Z,U,U,Z,Z,U,Z,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,Z,H,H,H,H,H,H,H,H,H,H,H,H,H,Z,H,H,H),
(Z,U,U,Z,Z,U,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,U,Z,Z,H,H,H,H,H,H,H,H,H,H,H,H,H,H,Z,H,H),
(Z,U,Z,U,U,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,U,Z,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,Z,H),
(Z,U,U,Z,U,Z,U,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,Z,U,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,H,Z));
Die ersten beiden Zeilen in der Matrix beziehen sich auf die Eigenschaften "Technik"
und "Wirtschaft". Die erste Zeile zeigt dazu an:
- die Eigenschaft "Wirtschaft" ist mit -1 festgelegt
33
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
- die Instanzen zu Bernd, Fritz, ... (ab Spalte 27) sind gesetzt. Alle übrigen Elemente
sind auf 0 gesetzt.
Die 2. Zeile zeigt:
- die Eigenschaft Technik ist mit -1 festgelegt, die Instanzen zu Anna, Liesel, ... sind
gesetzt. Alle übrigen sind auf 0 gesetzt.
Die folgende Tabelle beschreibt die Eigenschaften und die zugehörigen Einheiten
der Netzkonstanten:
Zeilenindex
1
2
3
4
5
6
7
8
9
10
11
12
...
...
27
...
...
Eigenschaft
nicht Wirtschaft
nicht Technik
nicht 30er
nicht 20er
nicht HS
nicht FOS
nicht KI, nicht GR
nicht SY, nicht GR
nicht SY, nicht KI
nicht (Fritz, Doris, ....)
nicht (Bernd, Doris, ....)
nicht (Bernd, Fritz, ....)
.....
.....
Beschreibung der Eigenschaften.
.................
.................
Instanzen
ab Spalte 27
ab Spalte 36
ab Spalte 27
ab Spalte 27
ab Spalte 27
ab Spalte 27
ab Spalte 27
ab Spalte 27
ab Spalte 27
in Spalte 27
in Spalte 28
in Spalte 29
.....
.....
.....
.....
.....
Die Konstante Netz wird der Variablen "Gewichte" zugeordnet. Externe Eingaben der
Einheiten sind zu 0 initialisiert, aktuelle Aktivierungswerte sind auf "-0.1" gesetzt.
type Vektor = array[1..Dim] of real;
Matrix = array[1..Dim,1..Dim] of real;
var
Aktivieren : Vektor;
ExtEing
: Vektor;
Gewichte
: Matrix;
procedure Initialisieren;
var I, J : integer;
begin
for I := 1 to Dim do
begin
Aktivieren[I] := -0.1;
ExtEing[I]
:= 0;
end;
for I := 1 to Dim do
for J := 1 to Dim do
Gewichte[I,J] := Netz[I][J];
end;
34
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.2.2 Mathematische Grundlagen
1. Berechnung der Aktivitäten
Einheiten in einem "iac-Netzwerk" können Aktivierungswerte erhalten, die von einem
Minimal- und Maximalwert eingegrenzt sind. Die aus der Aktivierung resultierende
Ausgabe entspricht dem Aktivierungswert. Die Aktivierungswerte ändern sich in dem
Netz kontinuierlich (Idealisierung) mit der Zeit.
Die Einwirkung auf eine spezielle Einheit, z.B. i, ist dann im Netz durch die folgende
Formel beschreibbar:
neti   wij  o j  ext _ inpi
j
oj entspricht im iac-Modell dem Aktivierungswert "aj.". "aj" beschreibt die Aktivierung
der Einheit "j", die mit der Einheit "i" in Verbindung steht und hat den Wert a j für alle
aj > 0. Die Gewichtung wij kann positive (verstärkend) oder negativ (hemmend) sein.
Das Resultat der Berechnungen von neti bewirkt folgende Veränderungen der
Aktivität:
neti  0
ai  (max  ai )  neti  decay  (ai  rest )
neti  0
ai  (ai  min )  neti  decay  (ai  rest )
"max", "min", "decay" sind Parameter. Übliche Werte sind: max = 1, min <= rest <= 0
"decay" liegt zwischen 0 und 1.
Angenommen "neti" bleibt konstant. Dann wird im Fall neti  0 ai abnehmen, die
Aktivierung der Einheit aber weiter wachsen. U.U. wird ai sogar negativ. Im
Gleichgewichtsfall ist ai  0 , d.h.:
0  (max  ai )  neti  decay  (ai  rest )  max  neti  decay  rest  ai  (neti  decay)
max  neti  rest  decay
ai 
neti  decay
neti
Falls max = 1 und rest = 0 ergibt sich: ai 
neti  decay
min  neti  decay  rest
Falls neti  0 ist, ergeben sich analoge Ergebnisse: ai 
neti  decay
min  neti
Mit rest  0 führt das zu: ai 
neti  decay
Da neti und "min" negativ sind, führt das in der vorliegenden Formel zu einiger
Verwirrung. Besser ist es, "min" durch "amin" und neti durch aneti zu ersetzen (d.h.
durch die Absolutwerte).
a min  aneti
ai 
aneti  decay
Die beiden Formeln für die Aktivierung beschreiben den Gleichgewichtsfall.
35
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Natürlich gibt es keine Garantie, daß sich unter wechselseitigen Einfluß die
unterschiedlichen Einheiten stabilisieren, in der Praxis ist eine solche Stabilisierung
jedoch häufig.
2. Beschreibung des Wettbewerbs
Bisher wurde betrachtet: Die Netzeinwirkung ist konstant und die Aktivierung bewegt
sich zu einem festen, stabilen Wert. Bei "iac"-Prozessen werden jedoch durch jede
Eingabe zu einer Einheit auch andere Einheiten derselben Gruppe beeinflußt.
Stehen 2 Einheiten "a" und "b" im Wettbewerb zueinander und erhalten sie
verstärkende Reize von außen, dann kann u.U. die verstärkende Einwirkung auf "a"
(ea) größer sein als auf b (eb). Wie stark sich der hemmende Einfluß der einzelnen
Einheiten bemerkbar macht, beschreibt der Parameter 
neta  ea    ausgabeb
netb  eb    ausgabea
Sind die Aktivierungen positiv " ausgabei  ai ", dann ist neta  ea    ab bzw.
netb  eb    aa
Eine stärkere Aktivierung von a führt zur Abnahme der Netzeingabe bzgl. b, ein
"Phänomen, das Grossberg mit "die Reichen werden immer reicher" erklärt hat.
3. Resonanz
Falls 2 Einheiten "a" und "b" wechselseitig sich verstärkende Verbindungen haben,
dann können sie auch sich wechselseitig aktiv halten. Manchmal können
Resonanzeffekte so stark werden, daß sie Schwundeffekte überwinden.
Falls bspw. 2 Einheiten "a" und "b" wechselseitig Verbindungen der Stärke " 2decay "
besitzen, und die Aktivitäten jeweils vom Wert 0.5 sind, dann wird ohne
Berücksichtigung externer Eingaben die Veränderung der Aktivierung:
aa  (1  aa )  neta  decay  aa  (1  0.5)  2  decay  0.5  decay  0.5  0
So können "iac"-Netzwerke wechselseitig sich verstärkende Verbindungen zwischen
Einheiten nutzen, wenn ein diesbezüglicher Eingabestrom unterbleibt. Weiterhin
kann auf diese Weise der Aktivierungsprozeß Einheiten anregen, die nicht durch
äußere Eingabe angestoßen wurden.
4. Hysterese und Blockierungen
Die Aktivierung einer Einheit kann die Blockade anderer Einheiten bedeuten.
Behindern sich 2 Einheiten "a" und "b" wechselseitig, ist die Behinderungsstärke
bspw. "   2  decay " und die Aktivierung von "a" auf 0.5 gesetzt, dann ist die
Netzeinwirkung bezogen auf die Einheit "b":
netb  eb    ab  eb  decay
36
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Wird anschließend die externe verstärkende Eingabe bzgl. "a" und "b" erhöht, bspw.
auf den Wert "decay", dann bleibt die Aktivierung von "a" (Wert: 0.5) erhalten und die
von "b" wird 0. Falls die Aktivierung von außen auf "b" erhalten bleibt, aber von "a"
zurückgezogen wird, wird schließlich auch "b" aktiviert. Das verzögerte Einsetzen der
Aktivierung wird als Hysterese bezeichenet.
5. Analyse des "iac"-Prozesses durch Grossberg
Verstärkende und hemmende Eingaben müssen getrennt behandelt werden.
Verstärkende Eingaben (ve) treiben die Aktivierung der Einheiten zum Maximum,
hemmende Eingaben (he) treiben die Aktivierung der Einheiten zum Minimum. Der
Faktor "decay" legt die Aktivierung auf ein Restniveau fest.
a  (max  a)  ve  (a  min )  he  decay(a  rest )
2.2.3 Implementierung des IAC-Modells
Die Implementierung ist in einem Pascal-Programm10 erfolgt
1. Parameter
Der Benutzer kann die Arbeitsweise durch eine Reihe von Paramtern steuern:
max (maximaler Aktivierungswert)
min (minimaler Aktivierungswert)
rest (verbleibender Aktivierungswert, den die Aktivierungen annehmen, falls externe
Eingaben ausbleiben)
decay (bestimmt die Stärke mit der der vebleibende Restwert der Aktivierung
berücksichtigt wird)
estr (bestimmt die Stärke der externen Eingabe. Damit wird der Einfluß der
externen Signale relativ zu den internen Eingaben bzgl. der Einheiten bemessen)
alpha (bestimmt die Stärke verstärkender Eingaben zu Einheiten von anderen
Einheiten des Netzwerks)
gamma (bestimmt die Stärke hemmender Eingaben zu Einheiten von anderen
Einheiten des Netzwerks)
Eine mögliche Initialisierung der Parameter ist:
10
37
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
const
Decay = 0.1;
Max
= 1.0;
Alpha = 0.1;
Min
= -0.2;
Gamma = 0.1; Estr
Rest = -0.1;
= 0.4;
2. Dynamische Aktivierung
In einer Folge von Arbeitsschritten (cycles) wird die Aktivierungszeit fortgeschrieben.
Jeder Zyklus beginnt mit dem Aktivierungswert der Einheiten, den sie im
vorangegangenen Zyklus erreicht haben. Danach werden die Aktivitäten der
Einheiten angepaßt Die Aktivierung erfolgt synchron.
Im Mittelpunkt der dynamischen Aktivierung steht folgende Bearbeitungsroutine:
type Vektor = array[1..Dim] of real;
Matrix = array[1..Dim,1..Dim] of real;
var
Aktivieren
Anregen
Hemmen
NetEing
ExtEing
Gewichte
:
:
:
:
:
:
Vektor;
Vektor;
Vektor;
Vektor;
Vektor;
Matrix;
procedure Zyklus;
var K : integer;
procedure BearbeiteNetz;
var I, J : integer;
begin
for I := 1 to Dim do
begin
Anregen[I] := 0; Hemmen[I] := 0;
for J := 1 to Dim do
begin
if Aktivieren[J] > 0 then
if Gewichte[I,J] > 0 then
Anregen[I] := Anregen[I] + (Gewichte[I,J] * Aktivieren[J])
else if Gewichte[I,J] < 0 then
Hemmen[I] := Hemmen[I] + (Gewichte[I,J] * Aktivieren[J])
else;
end;
NetEing[I] := Estr * ExtEing[I] + Alpha * Anregen[I]
+ Gamma * Hemmen[I];
end
end;
procedure AendereAktiv;
var I : integer;
begin
for I := 1 to Dim do
begin
if NetEing[I] > 0 then
Aktivieren[I] := Aktivieren[I] + ((Max - Aktivieren[I]) *
NetEing[I] - Decay * (Aktivieren[I] - Rest))
else Aktivieren[I] := Aktivieren[I] + ((Aktivieren[I] Min) * NetEing[I] - Decay * (Aktivieren[I] - Rest));
if (Aktivieren[I] > Max) then Aktivieren[I] := Max;
if (Aktivieren[I] < Min) then Aktivieren[I] := Min;
end
end;
begin (* Zyklus *)
for K := 1 to 100 do
38
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
begin
BearbeiteNetz;
AendereAktiv;
end;
end;
In der Prozedur Zyklus werden bei jedem Durchgang 2 Routinen aufgerufen:
BearbeiteNetz, AendereAktiv
BearbeiteNetz
berechnet die Netzeingabe für jede Einheit. Die Netzeingabe besteht aus der
- der externen Eingabe, bemessen mit dem Parameter estr
- den verstärkend wirkenden Eingaben anderer Einheiten, bemessen mit dem
Parameter alpha
- den hemmend wirkenden Eingaben von anderen Einheiten, bemessen durch den
Parameter gamma
Ob eine Verbindung hemmend oder verstärkend wirkt, ist nur durch ihr Vorzeichen
bestimmt (Gewichte[I,J] > 0 bzw. Gewichte[I,J] < 0. Die Operationen werden nur
dann ausgeführt, falls die Aktivierung der sendenden Einheit größer als 0 ist.
AendereAktiv
inkrementiert die Aktivierung jeder Einheit.
Die sich nach Durchlaufen der Übergangsphase (hier 100 Zyklen) einstellende
Verteilung von Aktivierungen in den Neuronen des Netzes läßt sich als ein
optimierter Zustand auffassen. Aktivierung wird in dem Maße zu Neuronen fließen,
die hohe Verbindungsstärken zu anderen Neuronen haben. Geringe Aktivierung
fließt zu Neuronen mit kleinen Gewichtswerten. Die Aktivierung wird sich in einer
Weise verteilen, die den Randbedingungen (, gegeben durch die vorgegebenen
positiven und negativen Gewichtswerte,) am besten entspricht.
3. Arbeitsweise
Sollen bspw. die individuelle Eigenschaften, die einem Namen zugeordnet sind,
gefunden werden, dann ist der Name über eine externe Eingabe dem Netz
mitzuteilen. Das Netz schaltet dann über die Aktivierung des Namens zu der
Aktivierung der Instanzen bis zur Aktivierung der Eigenschaften dieser Instanzen
weiter.
39
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3 Klassifikatoren und Musterassoziatoren
2.3.1 Beschreibung
NN können sich, das haben die vorliegenden Beispiele gezeigt 11 , wie
inhaltsadressierte Speicher verhalten. Sie verallgemeinern die Antworten auf neue
Eingaben, falls sie zu den gespeicherten Informationen ähnlich sind. Zusätzlich
sollten NN aber wiederholt auftretende Muster erkennen und klassifizieren können.
Vor allem sollten NN lernfähig sein, so daß kognitive Prozesse auf Rechnern
umfassend simuliert werden können.
Musterassoziatoren sind in der Regel Netzwerke mit einer Eingabe- und einer
Ausgabeschicht. Die Aktivierung breitet sich von der Eingabeschicht zur
Ausgabeschicht aus (Feedforward-Verbindungen). Falls die Gewichtswerte dieser
Verbindungen richtig eingestellt sind, entsteht auf der Ausgabeseite beim Abruf
genau dasjenige Muster, das (in der Menge der Zielmuster) dem Eingabemuster
während der Lernphase zugeordnet wurde. Zwei Muster sind miteinander assoziiert,
wenn das Eingabemuster (input pattern) das Zielmuster (target pattern) hervorruft.
Mit dieser Vorstellung gehören vorwärtsgerichtete Neuronale Netze, z.B. die
Perzeptron-Netze
zu
Musterassoziatoren,
obwohl
sie
eindeutig
nur
Klassikationsaufgaben lösen.

Häufig sieht man assoziative Netze etwas anders. Durch sie soll ein Vektor x auf

einen Vektor y abgebildet bzw. assoziiert werden. Doch der Unterschied zu einem


stetigen Abbildungsgesetz besteht darin, dass auch die Umgebungen von x auf y

abgebildet bzw. assoziiert werden. Ein Vektor, der nahe genug an einem Vektor xi

liegt, soll ebenfalls mit dem Vektor yi assoziiert werden. Dieses Verhalten wird durch
ein Trainingsverhalten erreicht. In der Praxis spricht man dann davon, dass
verrauschte Muster mit der korrekten Ausgabe assoziiert werden, was bspw. im
Bereich der Bilderkennung wichtig ist.
Assoziative Netze werden in der Regel mit einer Schicht von Neuronen
implementiert, die, je nach Typ, eine rekursive Rückkopplung12 erlauben oder nicht.
Die Verbindungen zwischen den Eingabestellen und den Neuronen sind gewichtet.
Falls die Aktivierungsfunktion die Identität ist, heissen die Neuronen lineare
  
Assoziatoren. Der Ausgabevektor berechnet sich dann folgendermaßen: x W  y
Es gibt drei (nicht-disjunkte) Klassen von assoziativen Netzen:
xi1
yi1
heteroassoziative Netze
xin
yik
Abb.: Verknüpfung von m Eingabevektoren mit m Ausgabevektoren. Die Dimension der
Eingabevektoren muß dabei nicht der Dimension der Ausgabevektoren entsprechen. In
heteroassoziativen Netzen wird eine Matrix
 
XW  Y erfüllt
11
12
vgl. 2.2
vgl. 2.5
40

W gesucht, die folgende Gleichung erfüllt:
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
xi1
xi1
autoassoziative Netze
xin
yin

 

x1 , x2 ,..., x n werden mit sich selbst assoziiert. wird eine Matrix W gesucht, die
 
folgende Gleichung erfüllt: XW  X erfüllt.
Abb.: Die Vekoren
xi1
Mustererkennungsnetze13
i
xin
Abb.: Assoziation der Eingabevektoren
 

x1 , x2 ,..., x n mit den Skalaren 1, 2, ... , m
2.3.2 Grundlagen
Einige Assoziativspeicher verwenden binäre Vektoren. Sie haben in jeder
Komponente entweder eine 1 oder 0. Damit entsprechen die gespeicherten
Mustervektoren eines n-dimensionalen Neuronalen Netzes jeweils den Ecken eines
Hyperwürfels, also (0,0), (0,1), (1,0) und (1,1). Anstatt das Spektrum der Vektoren
auf den Bereich 0 und 1 begrenzen, werden sog. Bipolarvektoren verwendet, deren
einzelne Werte –1 oder 1 sein können. Beide Vektordarstellungen sind praktisch
zueinander äquivalent, da sich durch eine Skalierung und Transformation des
binären Eingaberaums der bipolare erzeugen lässt.
(1,1)
1,1)
(1,0)
(1,-1)
Abb.: Binärvektoren und Bipolarvektoren.
Eine bipolare Darstellung hat den Vorteil, dass die Wahrscheinlichkeit, dass zwei
Vektoren orthogonal zueinander sind, größer ist als in der binären Darstellung.
Darüber hinaus kann als Aktivierungsfunktion für das Neuronale Netz in der Regel
die Vorzeichenfunktion sgn(x) mit Schwellenwert 0 verwendet werden.
 1 falls x  0 
sgn( x)  

 1 falls x  0
13
Mustererkennungsnetze sind eine besondere Untergruppe der heteroassoziativen Netze. Sie assoziieren

Eingabevektoren mit den Skalaren 1, 2, ... Hier sollen Vektoren, die in der Umgebung eines Vektors x i liegen,
korrekt benannt werden können.
41
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.2.1 Die Hebbsche Hypothese 14
Diese Regel dient zum Trainieren Neuronaler Netze und besagt: Falls zwei Einheiten
gleichzeitig aktiv sind, dann wächst die Stärke ihrer Verbindung. Am einfachsten
beschreibt das die folgende Formel:
(1)
wij    ai  a j
"   0 " bemißt die Größe des Lernschritts. Wird von Gewichten mit dem Wert 0
ausgegangen und baut sich das Netzwerk schrittweise auf, dann ist das Gewicht am
Ende einer Reihe von Lernschritten (indiziert durch l):
(2)
wij     ail  a jl
j
Aktivierungen können gesetzt werden durch:
1. Externe Eingaben
2. Interne Verbindungen innerhalb des Netzes
Im 2. Fall besteht häufig ein linearer Zusammenhang zwischen den verbundenen
Einheiten:
(3)
ai   a j  wij
j
Bsp.: Trainieren mit der Hebbschen Regel
1. Ein positiver Fall
1
0
2
Dieses NN soll aus Eingabemustern
Ausgabemuster erzeugen.
14
vgl. 1.2.3
42
nach
folgender
Zusammenstellung
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Eingabe
0
1
1
-1
-1
Eingabe
1
1
-1
1
-1
Ausgabe
2
1
1
-1
-1
Nach der Hebbschen Regel (Gleichung 1) erhält w20 den Wert von  (Annahme:
  1. 0 ) zugeordnet, w21 dagegen wird reduziert auf den Wert 0. Eingabemuster 0
korreliert zum Ausgabemuster. Auf diese Weise können über die Hebbsche
Hypothese Assoziationen erlernt werden.15
2. Ein negativer Fall
0
1
2
3
4
Das NN soll aus Eingabemustern nach folgender Zusammenstellung ein
Ausgabemuster erzeugen:
Eingabe
0
1
1
1
1
1
-1
1
1
-1
2
1
1
1
-1
3
-1
1
-1
1
Ausgabe
4
1
1
-1
-1
3 der möglichen Verbindungen zwischen Eingabe- und Ausgabeschicht führen auf
den Wert 0 (keine Korrelation zwischen den Aktivitäten). Nur Einheit 2 hat zur
Ausgabeeinheit eine positive Korrelation.
Eine Lösung der vorliegenden Aufgabe kann durch die folgende Zuordnung von
Werten zu den Verbindungen erreicht werden:
0
1
-1
2
2
-1
3
1
4
15
vgl. 1.2.1
43
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.2.2 Die Hebbsche Hypothese in Musterassoziator-Modellen
2.3.2.2.1 Lernphase
Der Wert einer jeden Gewichtung im Musterassoziator ergibt sich für einen einzigen
Lernschritt zu
wij    i jl  oil
(7)

ijl..... Aktivierung der Eingabeeinheit j im Eingabemuster i l

oil.... Aktivierung der Ausgabeeinheit i im Ausgabemuster o il
2.3.2.2.2 Testphase

Ein Eingabemuster i t führt auf ein Ausgabemuster. Falls die Einheiten sich linear
verhalten, gilt
oit   wij  i jt
(8)
j
Mit (7) folgt:
oit     i jl  oil  i jt
(9)
j
(10)
oit    oil   i jl  i jt
j
Die Summe der Produkte korrespondierender Elemente zweier Vektoren ist das


Skalarprodukt. Im vorliegenden Fall drückt es die Ähnlichkeit der Muster i l und i t
aus.
Oft ist es nützlich, das Skalarprodukt zu normalisieren 16. Für Muster, die nur aus
Elementen mit Werten von "1" und "-1" bestehen, entspricht das normalisierte
Skalar-Produkt der Korrelation zwischen zwei Mustern. Das Produkt ist "1", falls die
Muster identisch sind; "-1", falls die Muster entgegengesetzt sind; "0", falls sich die
Muster unkorelliert verhalten.
Gleichung (10) kann dann so geschrieben werden:
 
(11)
oit  k  oil  (il  i t ) n
k  n   (n ist die Anzahl der Einheiten)


( i l  i t ) n ist das normalisierte Skalarprodukt.
Alle Elemente des Ausgabemusters werden dann erfaßt:

(12)
16



o t  k  o l  ( i l  it ) n
vgl. 1.2.4
44
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Gleichung (12) besagt: Das Ausgabemuster, das beim Test vom Netzwerk erzeugt
wird, ist das Produkt des während des Lernschritts gespeicherten Musters mit einem
Skalar.
Die Stärke des Modells ist proportional der Ähnlichkeit zwischen trainierten und
getesteten Mustern.
Falls k = 1 und das Testmuster identisch mit dem Trainingsmuster ist, ist die
Ausgabe beim Test identisch zur Ausgabe beim Lernen.
1. Präsentation mehrerer Muster während der Trainingsphase
Falls eine ganze Reihe von Mustern während der Lernphase auf das Netz
zukommen, bestimmen sich die Gewichte aus
(13)
wij     i jl  oil
l
und die Ausgabe, die von jedem Testmuster produziert wird, ist

(14)



o t  k   o l  ( i l  i t )n
l
2. Folgerungen
1. Ist das Testeingabemuster orthogonal zu all den Eingabemustern der
Trainingsphase, dann ist die Ausgabe des Netzwerks 0.
2. Falls ein Eingabemuster sich ähnlich zu einem der erlernten Eingabemuster
verhält, und unkorreliert zu allen anderen ist, dann entspricht die Ausgabe des
Tests der Ausgabe, die vom ähnlichen Eingabemuster während der Lernphase
ermittelt wurde. Die Stärke der Übereinstimmung bzgl. dieser Ausgabe richtet sich
nach dem Grad der Übereinstimmung der Eingabemuster.
3. Für andere Eingabemuster ist die Ausgabe ein Spiegel der Ausgabe bei der
Lernphase. Jedes Ausgabemuster ist die gewichtete Zusammenfassung
korrespondierender Eingabemuster der Test- bzw. Trainingsphase. Falls die
Eingabemuster, die während des Trainings benutzt wurden, keine orthogonale
Menge bilden, ist es allgemein nicht möglich, Störungen (Übersprechen) zu
vermeiden
2.3.2.2.3 Beispiele
2.3.2.2.3.1 Beispiel 1
1. Aufgabenstellung
Gegeben sind folgende Musterpaare
a. Eingabemuster: (1,-1,1,-1,1,1,-1-1)
Zu erlernendes Muster: (1,1,-1,-1,1,1,-1,-1)
45
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
b. Eingabemuster: (1,1,-1,-1,1,-1,1,-1)
Zu erlernendes Muster: (1,1,1,1,-1,-1,-1,-1)
c. Eingabemuster: (1,-1,-1,1,1,1,1,1)
Zu erlernendes Muster: (1,-1,-1,1,1,-1,-1,1)
2. Lernphase
Berechnung der Gewichtsänderungen wij    oi  i j unter der Annahme   0.125 .
1. Schritt (Muster (a))
0.125
0.125
-0.125
-0.125
...
...
...
...
-0.125
-0.125
0.125
0.125
...
...
...
...
0.125
0.125
-0125
-0.125
...
...
...
...
-0.125
-0.125
0.125
0.125
...
...
...
...
0.125
0.125
-0.125
-0.125
...
...
...
...
0.125
0.125
-0.125
-0.125
...
..
...
...
-0.125
-0.125
0.125
0.125
...
...
...
...
-0.125
-0.125
0.125
0.125
...
...
...
...
0
0
-0.25
-0.25
0.25
0.25
0
0
-0.25
-0.25
0
0
0
0
0.25
0.25
0.25
0.25
0
0
0
0
-0.25
-0.25
0
0
-0.25
-0.25
0.25
0.25
0
0
0
0
0.25
0.25
-0.25
-0.25
0
0
-0.25
-0.25
0
0
0
0
0.25
0.25
-0.125
0.125
-0.125
-0.375
0.125
0.375
0.125
-0.125
-0.125
-0.375
-0.125
0.125
0.125
-0.125
0.125
0.375
0.375
0.125
-0.125
0.125
0.125
-0.125
-0.375
-0.125
0.125
-0.125
-0.375
-0.125
0.375
0.125
-0.125
0.125
0.125
-0.125
0.125
0.375
-0.125
-0.375
-0.125
0.125
-0.125
-0.375
-0.125
0.125
0.125
0.125
0.125
0.375
2. Schritt (Muster (b))
0.25
0.25
0
0
0
0
-0.25
-0.25
0
0
0.25
0.25
-0.25
-0.25
0
0
3. Schritt (Muster (c))
0.375
0.125
-0.125
0.125
0.125
-0.125
-0.375
-0.125
-0.125
0.125
0.375
0.125
-0.375
-0.125
0.125
-0.125
3. Trainingsphase


 
Nach Gleichung (14) ist o  k   ol  ( il  it ) n
l
Diese Formel zeigt: In allen 3 Fällen muß das Netzwerk das erlernte Zielmuster
richtig reproduzieren, da die 3 Eingabevektoren zueinander orthogonal sind.
Das führt zu dem folgenden Ergebnis:
1. Der Aufruf von Eingabemuster (a) führt auf die gewünschte Ausgabe des
zugeordneten Ziels
46
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Der Aufruf von Eingabemuster (b) führt auf die gewünschte Ausgabe des
zugeordneten Ziels
3. Der Aufruf von Eingabemuster (c) führt auf die gewünschte Ausgabe des
zugeordneten Ziels
Begründung
Eingabemuster (c) (1,-1,-1,1,1,1,1,1)


Gleichung (11) ist bestimmt durch die Berechnung des Skalarprodukts: ( i l  i t ) n

1
 (1, 1, 1,1,1,1,1,1)
8

1
i l1 
 (1, 1,1, 1,1,1, 1, 1)
8
it 


i t  i l1  0

i l2 
1
 (1,1, 1, 1,1, 1,1, 1)
8
.......
2.3.2.2.3.2 Beispiel 2
1. Aufgabenstellung
Gegeben sind folgende Musterpaare
a. Eingabemuster: (1,-1,1,-1,1,1,-1-1)
Zu erlernendes Muster: (1,1,-1,-1,1,1,-1,-1)
b. Eingabemuster: (1,1,-1,-1,1,-1,1,-1)
Zu erlernendes Muster: (1,1,1,1,-1,-1,-1,-1)
c. Eingabemuster: (1,-1,1,-1,1,1,1,1)
Zu erlernendes Muster: (1,-1,-1,1,1,-1,-1,1)
2. Lernphase
Berechnung der Gewichtsänderungen wij    oi  i j unter der Annahme   0.125 .
1. Schritt (Muster (a))
0.125
0.125
-0.125
-0.125
0.125
0.125
-0.125
-0.125
-0.125
-0.125
0.125
0.125
-0.125
-0.125
0.125
0.125
0.125
0.125
-0125
-0.125
0.125
-0.125
-0.125
-0.125
-0.125
-0.125
0.125
0.125
-0.125
-0.125
0.125
0.125
0.125
0.125
-0.125
-0.125
0.125
0.125
-0.125
-0.125
47
0.125
0.125
-0.125
-0.125
0.125
0.125
-0.125
-0.125
-0.125
-0.125
0.125
0.125
-0.125
-0.125
0.125
0.125
-0.125
-0.125
0.125
0.125
-0.125
-0.125
0.125
0.125
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Schritt (Muster (b))
0.25
0.25
0
0
0
0
-0.25
-0.25
0
0
0.25
0.25
-0.25
-0.25
0
0
0
0
-0.25
-0.25
0.25
0.25
0
0
-0.25
-0.25
0
0
0
0
0.25
0.25
0.25
0.25
0
0
0
0
-0.25
-0.25
0
0
-0.25
-0.25
0.25
0.25
0
0
0
0
0.25
0.25
-0.25
-0.25
0
0
-0.25
-0.25
0
0
0
0
0.25
0.25
0.125
-0.125
-0.375
-0.125
0.375
0.125
-0.125
0.125
-0.375
-0.125
0.125
-0.125
-0.125
0.125
0.375
0.125
0.375
0.125
-0.125
0.125
0.125
-0.125
-0.375
-0.125
0.125
-0.125
-0.375
-0.125
0.375
0.125
-0.125
0.125
0.125
-0.125
0.125
0.375
-0.125
-0.375
-0.125
0.125
-0.125
-0.375
-0.125
0.125
0.125
-0.125
0.125
0.375
3. Schritt (Muster (c))
0.375
0.125
-0.125
0.125
0.125
-0.125
-0.375
-0.125
-0.125
0.125
0.375
0.125
-0.375
-0.125
0.125
-0.125
3. Trainingsphase


 
Nach Gleichung (14) ist o  k   ol  ( il  it ) n
l
Das führt zu dem folgenden Ergebnis:
Abruf Muster (a)






Mit dem Eingabemuster zu (a) ist das Skalarprodukt ( i l  i t ) n 1
Mit dem Eingabemuster zu (b) ist das Skalarprodukt ( i l  i t ) n 0
Mit dem Eingabemuster zu (c) ist das Skalarprodukt ( i l  i t ) n 1/2
Berücksichtigt werden muß demnach:
Der Ausgabevektor zu (a) (1,1,-1,-1,1,1,-1,-1) mit dem Faktor 1
Der Ausgabevektor zu (c) (1,-1,-1,1,1,-1,-1,1) mit dem Faktor 0.5
Die Summe der beiden Produkte führt auf den neuen Ausgabevektor (1.5,0.5,-1.5,0.5,1.5,0.5-1.5,-0.5)
Abruf Muster (b)






Mit dem Eingabemuster zu (a) ist das Skalarprodukt ( i l  i t ) n 0
Mit dem Eingabemuster zu (b) ist das Skalarprodukt ( i l  i t ) n 1
Mit dem Eingabemuster zu (c) ist das Skalarprodukt ( i l  i t ) n 0
d.h.: Muster (b) ist orthogonal zu Muster (a) bzw. Muster (c).
48
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.2.3 Delta-Regel (Widrow&Hoff-Regel) 17
wij     i  a j
(4)
i  ti  ai
Aus der Differenz von gewünschtem und erzieltem Ausgabeverhalten berechnet man
einen Fehlerkorrekturwert, das sog. Delta und ändert die Gewichte in Abhängigkeit
von diesem Fehlerkorrekturwert.
Bsp.:
0
1
2
3
4
Das NN soll aus Eingabemustern nach folgender Zusammenstellung ein
Eingabemuster erzeugen.
Muster
Eingabe
0 1 2 3
1 -1 1 -1
1 1 1 1
1 1 1 -1
1 -1 -1 1
0
1
2
3
Ausgabe
4
1
1
-1
-1
Nach der Delta-Regel sind die Gewichte der Verbindungen zwischen den Einheiten
der Ein- und Ausgabeschicht zuzuordnen. Die Gewichte sind mit 0 initialisiert, die
Lernrate  hat den Wert 0.25.
Zuerst wird Muster 0 betrachtet. Das führt auf den Ausgabewert 0. Zum
vorgegebenem Ziel ergibt sich die Differenz 1, d.h. Änderungen der Gewichte sind
proportional zu den Aktivierungen der Eingabeeinheiten. Das führt zur folgenden
Tabellenzeile für Muster 0.
Muster
0
Eingabe
Ziel
1 -1 1 -1
1
Ausgabe
0.0
Fehler
wij
wij
1.0
0.25 -0.25 0.25 -0.25
0.25 -0.25 0.25 -0.25
Im vorliegenden Fall entsprechen die den neuen Werten für die Gewichte. Sie
werden mit dem nächsten Eingabemuster (1 1 1 1) paarweise multipliziert, die
einzelen Resultate werden anschließend aufsummiert. Das ergibt einen
Ausgabewert von 0, die Differenz zum Ziel ist wieder 1. Den weiteren Verlauf der
Rechnung dokumentiert die folgende Tabelle:
Schritt 0
17
vgl. 1.2.3
49
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Muster
0
1
2
3
Eingabe
0 1 2 3
1 -1 1 -1
1 1 1 1
1 1 1 -1
1 -1 -1 1
Ziel
1
1
-1
-1
Ausgabe
0.00
0.00
1.00
1.00
Fehler
wij
1.00
1.00
-2.00
-2.00
0.25 -0.25
0.25 0.25
-0.5 -0.5
-0.5 0.5
wij
025 -0.25
0.25 0.25
-0.5 0.5
0.5 -0.5
0.25 -0.25
0.5 0
0.0 -0.5
-0.5 0.0
0.25 -0.25
0.5 0
0.0 0.5
0.5 0.0
Ein Maß für die erzielte Annäherung an eine perfekte Lösung (, die im ersten Schritt
natürlich nicht erreicht wurde,) ist die Summe der Quadrate der Einzelfehler (totale
Summe der Quadrate).
TSQ = 10
Dieser Wert erniedrigt sich nach jedem Schritt.
Nach etwa 20 Schritten (Trainings-Epochen) wird TSQ = 0.00. Das Ergebnis nähert
sich damit der perfekten Lösung.
Die Delta-Regel ist bei weitem mächtiger als die Hebbsche Hypothese. Tatsächlich
kann nachgewiesen werden: Diese Regel bestimmt Gewichte so, daß
der
Fehlerkorrekturwert beliebig nahe an 0 gebracht werden kann. Solch eine Menge
von Gewichten existiert für jedes Paar aus Eingabemuster und Ziel, falls das Ziel aus
einer gewichteten Summe (lineare Kombination) der Eingabemuster bestimmt
werden kann. In diesem Fall muß die Menge der Gewichte der Bedingung
tip   wij  a jp
j
für alle Ausgabeeinheiten der Muster p genügen 18.
2.3.2.4 Die Delta-Regel in Musterassoziator-Modellen
1. Lernphase
(15)
wij    ( til  oil )  i jl
Im Rahmen einer Reihe von Lernschritten (indiziert durch l) kann geschrieben
werden:
(16)
wij     ( til  oil )  i jl
l

Im Fall der Orthogonalität ist o l  0 und dann reduziert sich die Formel auf:
(17)
wij     til  i jl
l
In diesem Fall produziert die Delta Regel die gleichen Ergebnisse wie die Hebbsche
Hypothese (Gleichung (13)). Solange sich die Muster orthogonal verhalten, gibt es
kein "Übersprechen".
18
vgl. 1.2.4, lineare Unabhängigkeit
50
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Trainingsphase
Die während der Testphase resultierenden Änderungen im Ausgabevektor der
Einheiten i sind bestimmt durch
oit  wij  i jt    ( til  oil )  i jl  i jt




Das kann man auch so schreiben:  o t  k  fehler l  ( i l  i t ) n
Folgerungen:
1. Ist die Eingabe beim Lesen gleich der Eingabe beim Test, dann ist das
normalisierte Skalarprodukt 1. Ist k auch 1.0, dann ist die Änderung der Ausgabe
exakt gleich dem Fehlermuster.




2. Ist i t verschieden zu i l (, allerdings nicht so verschieden, daß ( i l  i t ) n 1 oder 0

ist), dann wird die durch i t erzeugte Ausgabe vom Lernversuch beeinflußt. Die


Stärke der Beeinflußung ist proportional zu ( i l  i t ) n .
3. Lineare Unabhängigkeit

Ein bestimmtes Ausgabemuster o p kann in Beziehung gesetzt werden zu einem

speziellen Eingabemuster i
p
, ohne daß es zu ruinösen Störungen zwischen

anderen Eingabe/Ausgabe-Paaren kommt, falls i p nicht Linearkombination anderer
Eingabemuster ist. Ein solches Muster heißt linear unabhängig von anderen
Mustern. Sind allle Elemente einer Menge von Mustern linear unabhängig, dann
spricht man auch von einer Menge linear unabhängiger Elemente.
2.3.3 Implementierung19
1. Aktivierung der Ausgabeeinheiten
Jeder Musterassoziator besteht aus einer Reihe von Ein- und Ausgabeeinheiten. Die
Einwirkung der Eingabeinheiten j auf eine spezielle Ausgabeeinheit i kann so
beschrieben werden:
neti   wij  a j  biasi
j
19
Die Implementierung ist in einem Pascal-Programmerfolgt.
51
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Aus der Netzeinwirkung wird die Aktivierung jeder Ausgabeeinheit über die
Aktivierungsfunktion bestimmt. Im vorliegenden Fall verhält sich die Aktivierung
linear zur Netzeinwirkung (Aktivierung = Netzeinwirkung)
2. Vereinbarungen
Verbindungen bestehen von den Eingabeeinheiten zu den Ausgabeeinheiten. Zu
Beginn sind diese Verbindungen mit dem Gewichtswert 0 initialisiert. Die für das
Netzwerk charakteristischen Werte sind:
const
AnzEingEinh = 8;
AnzAusgEinh = 8;
LRate
= 0.125;
type
Matrix
Vektor
EinVektor
AusVektor
=
=
=
=
array[1..AnzEingEinh,1..AnzAusgEinh] of real;
array[1..AnzAusgEinh] of real;
array[1..AnzEingEinh] of integer;
array[1..AnzAusgEinh] of integer;
var
W
: Matrix;
Schwellwerte : Vektor;
Eingabe : EinVektor;
Ausgabe : Vektor;
Fehler
: Vektor;
Ziel
: AusVektor;
NetzEing : Vektor;
MSQ, VKOR, NVL, NSP,
Hebb
:
AnzSchritte
:
Fehlerschrittweite :
TSQ : real;
boolean;
integer;
real;
3. Initialisieren
Die Prozedur Initialisieren
Netzparameter:
übernimmt
das
Setzen
der
procedure Initialisieren;
var I, J : integer;
begin
TSQ := 0; MSQ := 0; NSP := 0; VKOR := 0; NVL := 0;
for I := 1 to AnzEingEinh do
for J := 1 to AnzAusgEinh do W[I,J] := 0.0;
for I := 1 to AnzAusgEinh do
begin
Schwellwerte[I] := 0.0; NetzEing[I]
:= 0.0;
Ausgabe[I]
:= 0.0; Fehler[I]
:= 0.0;
end;
for I := 1 to AnzEingEinh do Eingabe[I] := 0;
for I := 1 to AnzAusgEinh do Ziel[I]
:= 0;
end;
52
Anfangswerte
der
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Trainieren
Die Prozedur Trainieren wird zum Erlernen der ausgewählten Muster eine Anzahl
von Epochen (AnzSchritte) ausgeführt. Falls die Meßgröße TSQ eine vorgegebene
Schranke (Fehlerschrittweite) unterschreitet, ist das Testziel erreicht.
procedure Trainieren;
var L : integer;
begin;
for L := 1 to AnzSchritte do
begin
TSQ := 0.0;
Versuch; AendereGewichte;
if TSQ < Fehlerschrittweite then exit;
end;
end;
Trainieren ruft die Prozeduren "Versuch" und "AendereGewichte" auf.
procedure Versuch;
var K : integer;
procedure SetzeMuster;
var I : integer;
begin
for I := 1 to AnzAusgEinh do Ausgabe[I] := Eingabe[I];
end;
procedure BerechneAusgabe;
var I, J : integer;
begin
for I := 1 to AnzAusgEinh do
begin
NetzEing[I] := Schwellwerte[I];
for J := 1 to AnzEingEinh do
begin
NetzEing[I] := NetzEing[I] + Eingabe[J] * W[I,J];
end;
Ausgabe[I] := NetzEing[I];
(* Aktivierungsfunktion *)
end;
end;
procedure BerechneFehler;
var I : integer;
begin
for I := 1 to AnzAusgEinh do Fehler[I] := Ziel[I] - Ausgabe[I];
end;
procedure SumStatistik;
begin
MSQ := SummeQuadrate(Ziel,Ausgabe,AnzAusgEinh);
VKOR := VekKor(Ziel,Ausgabe,AnzAusgEinh);
NVL := VekLaenge(Ausgabe,AnzAusgEinh);
NSP := SkalarProdukt(Ziel,Ausgabe,AnzAusgEinh);
TSQ := TSQ + MSQ;
end;
begin
SetzeMuster;
BerechneAusgabe;
BerechneFehler;
SumStatistik;
end;
Die Prozedur "SumStatistik" ermittelt Meßgrößen zur Beurteilung der Performance.
53
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Diese Meßgrößen sind:
- das normalisierte Skalarprodukt NSP
function Skalarprodukt(V1 : AusVektor; V2 : Vektor; L : integer) : real;
var I : integer;
SP : real;
begin
SP := 0.0;
if L = 0 then SkalarProdukt := 0.0
else begin
for I := 1 to L do SP := SP + V1[I] * V2[I];
SkalarProdukt := SP / L;
end;
end;
- die normalisierte Vektorlänge NVL (bestimmt den Betrag des normalisierten
Ausgabevektors)
function VekLaenge(V : Vektor; L : integer) : real;
var I : integer;
VL : real;
begin
VL := 0.0;
if L = 0 then VekLaenge := 0.0
else begin
for I := 1 to L do VL := VL + (V[I] * V[I] / L);
VekLaenge := sqrt(VL);
end;
end;
- Die Vektorkorrelation VKOR
Sie bemißt die Ähnlichkeit von Vektoren (unabhängig von der Länge). Ihr Wert ist
-- "1.0" für Vekoren, die perfekt korrelieren
-- "0.0" für orthogonale Vektoren
-- "-1.0" für Vektoren, die sich antikorreliert verhalten.
function VekKor(V1 : AusVektor; V2 : Vektor; L : integer) : real;
var I
: integer;
DP, L1, L2 : real;
begin
DP := 0.0; L1 := 0.0; L2 := 0.0;
for I := 1 to L do
begin
DP := DP + V1[I] * V2[I]; L1 := L1 + V1[I] * V1[I];
L2 := L2 + V2[I] * V2[I];
end;
if (L1 = 0.0) or (L2 = 0.0) then VekKor := 0.0
else VekKor := DP / (sqrt(L1*L2));
end;
Falls sich das Zielmuster aus +1 und -1 zusammensetzt, besteht folgender
Zusammenhang:
NSP = NVL + VKOR
54
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Zusätzlich zu diesen Meßgrößen werden berechnet: MSQ und TSQ. "MSQ" ist die
Summe aller zum Quadrat erhobenen Fehler, die bei den Ausgabeeinheiten
festgestellt wurden. Der Fehler bzgl. der Ausgabeeinheiten ist die Differenz zwischen
vorgegebenem Ziel und der tatsächlich erhaltenen Aktivierung.
function SummeQuadrate(V1 : AusVektor; V2 : Vektor; L : integer) : real;
var I : integer;
SS : real;
begin
SS := 0;
for I := 1 to L do
SS := SS + ((V1[I] - V2[I]) * (V1[I] - V2[I]));
SummeQuadrate := SS;
end;
"TSQ" ist die Summe aller MSQ-Werte, die während der Trainingsphase für jedes
Muster errechnt wurden
Über die Prozedur "AendereGewichte" wird die Anpassung der Gewichtswerte
während der Lernphase vollzogen:
procedure AendereGewichte;
var I, J : integer;
begin
if Hebb then
for I := 1 to AnzAusgEinh do
begin
Ausgabe[I] := Ziel[I];
for J := 1 to AnzEingEinh do
W[I,J] := W[I,J] + LRate * Ausgabe[I] * Eingabe[J];
Schwellwerte[I] := Schwellwerte[I] + 0.0 * Ziel[I];
end
else
for I := 1 to AnzAusgEinh do
begin
for J := 1 to AnzEingEinh do
W[I,J] := W[I,J] + LRate * Fehler[I] * Eingabe[J];
Schwellwerte[I] := Schwellwerte[I] + 0.0 * Fehler[I];
end;
end;
55
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.4 Das Perzeptron
Das Perzeptron-Modell wurde 1958 von Frank Rosenblatt entwickelt. Das Modell
kann die Klassifikation von Mustern erlernen.
2.3.4.1 Biologische Grundlagen
Das Perzeptron ist die Nachbildung eines biologischen Neurons 20.
2.3.4.2 Funktionsweise
Aus den Kentnissen über das biologische Neuron kann man ein mathematisches
Modell für das Perzeptron ableiten. So ist die Ausgabe "o" bestimmt durch
N
1, falls net   wi  ii> 
i 1
o={
0, anderenfalls
Zur vereinfachten Darstellung der Perzeptrone kann die Schwelle  auf Null normiert
werden. Hierfür wird ein zusätzlicher Eingang, an dem immer eine Eins anliegt
erstellt, erstellt und dessen Gewicht auf das Negative des ursprünglichen
Schwellenwerts gesetzt werden. Man spricht dann von einem (so genannten) Bias.
i1
i2
iN
.....
o
Abb.2.3-1: Einschichtiges Perzeptron
Jede Eingangsinformation wird mit dem zugehörigen Gewicht multipliziert, das den
unterschiedlichen Übertragungswiderstand der Synapsen simuliert. Nach der
Summenbildung aller Eingangswerte entscheidet die Aktivierungsfunktion F über die
20
vgl. 1.1.1, Aufbau einer Nervenzelle
56
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Höhe des Ausgangssignals, das zu den angeschlossenen Neuronen übertragen
werden soll.
2.3.4.3 Lernen mit der Delta-Regel
Das Perzeptron setzt sich aus Gewichten der Verbindungen, dem Addierer und aus
einen einstellbaren Schwellwert (Bias) zusammen. Lernen bedeutet: Ändern der
Gewichte und Einstellen des Schwellwerts (Bias). Häufig wird der Schwellwert
(Bias)21 über ein peripheres Gewicht (w0) berücksichtigt.
Falls bei einem Muster p und einer Einheit i die Differenz zwischen Zielwert tip und
korrespondierendem Ausgabewert oip vom Wert 0 ist, ist das Lernziel erreicht.
Andernfalls werden Schwellwert und Verbindungsgewichte wij angepaßt.
Das Training des Schwellwerts läßt sich durch folgende Formel beschreiben:
Biasi  Biasi    ( tip  oip )
Das Training der Gewichte erfolgt über die Formel:
wij  wij    ( tip  oip )
Ein Perzeptron berechnet 0 oder 1 aus den vorliegenden Eingaben. Mehrere
berechnen komplexe Funktionen.
i1
i2
.......
iN
1
Abb.2.3-2: Perzeptron mit N Eingangssignalen und drei Ausgangssignalen
Da jedes Perzeptron unabhängig ist, können sie getrennt trainiert werden.
Die Schwelle  kann so auf Null normiert werden. Es wird, wie bereits angegeben, ein zusätzliche Eingang,
an dem immer eine Eins anliegt, erstellt und dessen Genauigkeit auf das Negative des ursprünglichen
Schwellenwerts gesetzt.
21
57
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.4.4 Lineare Trennbarkeit
i2
i1
Abb. 2.3-3: Lineare Trennnbarkeit zur Mustererkennung
Gegeben sind die Ausprägungen von 2 Eingabemustern. Das Perzeptron soll 1
ausgeben, falls es die Eingabe zu den weißen Punkten zuordnet bzw. 0, falls es die
Eingabe zu den schwarzen Punkten zuordnet.
net  w0  w1  i1  w2  i2
1, falls net > 0
o={
0, falls net < 0
w
w
i2   1  i1  0
w2
w2
Die Gleichung trennt die beiden Muster (Trennfläche). Im Fall umfangreicher
Eingaben, erweitert sich die Trennfläche zur Hyperfläche:
N
 w i
i
i
0
i 1
Funktionen, für die eine solche Hyperfläche existiert, werden "linear trennbar"
genannt. Das Problem des Lernens reduziert sich damit auf das Problem, eine
solche Trennfläche zu finden.
Lineare Trennbarkeit bedeutet also: Zwei Mengen P und N von Punkten in einem
n-dimensionalen Eingaberaum sind linear trennbar, falls n+1 reelle Zahlen  , w1, w2,
n

... ,wn existieren, so dass für jeden Punkt x  P gilt:  wi xi   und für jeden Punkt
i 1

x  N gilt:
n
w x
i 1
i
i
 .
58
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Trennfunktion
entspricht
einer
Geradengleichung:
w1 x1  w2 x2  
w

x2 
 1 x1 . Die Trenngerade steht senkrecht zum Gewichsvektor.
w2 w2
Die
x2

w
h (Projektion von


x auf w

x
d
x1
Abb.: Der Vektor der Trenngeraden ist mit
x 2  0  x1 

w1
und
x1  0  x 2 

w2
:
  

   0  
      w1 
 w1        
 0
   w2    w 
2 

 
 


Das Skalarprodukt des Vektors w mit der Trenngeraden ist  w1   w2  0 . w
 w1 
 w2 
ist immer die Normale zur Hyperebene. Für einen beliebigen Punkt auf der
   

Trennfläche gilt (h=d):   wT  x  w x cos  und d 
.
w
Die lineare Trennfunktion ist die (n-1)-dimensionale Hyperebene des ndimensionalen
Eingaberaums.
Eine
Perzeptron-Definition
mit
spezieller
Eingabekomponente x 0 und Gewicht w0   bedeutet, dass die Trennfunktion
 
durch wT  x  0 gegeben ist. Diese geht wegen d  0 durch den Ursprung des um
eine Dimension erhöhten Eingaberaums.
Für das XOR-Problem (vgl. Wertetafel) existiert bspw. keine derartige Trennfäche
(Gerade).
Eingabe
0
0
1
1
Eingabe
0
1
0
1
Ausgabe
0
1
1
0
Die folgende 4 Ungleichungen
0  w1  0  w2  
0  w1  1 w2  
1 w1  0  w2  
1 w1  1 w2  
59
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
zeigen: w1 und w2 können allein für sich allein betrachtet nicht größer sein als ihre
Summe, d.h. Das XOR-Problem ist mit einem Perzeptron nicht lösbar. Das zeigt die
folgende grafische Darstellung:
i2
(1,1)
1
1
0
0
1
1
i1
AND und OR sind dagegen lösbar:
i2
i2
(1,1)
(1,1)
1
1
0
1
1
1
0
0
0
1
1
1
i1
i1
Abb. 2.3-4: Lineare Trennbarkeit logischer Funktionen
Auch das folgende Problem ist lösbar:
Eingabe
0
0
1
1
Eingabe
0
1
0
1
Eingabe
0
0
0
1
Ausgabe
0
1
1
0
Die ersten beiden Spalten entsprechen der Eingabe beim XOR, die 3. Spalte umfaßt
eine logisches UND der Eingabe zum XOR.
60
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
(1,1,1)
0
(0,1,0)
0
1
(1,0,0)
(0,0,0)
Abb. 2.3-5: Schwellenwertebene für das XOR-Problem:
Die Überführung des zweidimensionalen in ein dreidimensionales Problem zeigt
einen Lösungsweg für das XOR-Problem. Allerdings ist ein 3. Eingabeelement (in
einer zusätzlichen verborgenen Schicht) erforderlich.
i1
w1
i2
i3
w2
w3
o
Abb. 2.3-6: Einfaches XOR-Netzwerk mit einem verdeckten Element
Die zusätzliche (verborgene) Schicht empfängt keine externe Eingaben. Sie muß
aber trainiert werden, d.h.: Es muß extra dafür eine Lernprozedur geben. Lange hat
man geglaubt: Eine solche Prozedur gibt es nicht. Eine Verallgemeinerung der DeltaRegel22 zeigt jedoch eine Lösung des Problems.
22
vgl. 2.5
61
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.4.5 Applet: Perzeptron-Netz zur Rekodierung von Zahlen
1. Aufgabenstellung
Ein binär angegebener Wert einer Zahl ist in die entsprechende dezimale Form
umzuwandeln. Der dezimale Wert erhält soviele Einsen in aufsteigender Folge
zugeordnet, wie es dem binären Wert entspricht. Die Eingabe einer Zahl von 0..9,
z.B. 8 führt zur Ausgabe von: 1 1 1 1 1 1 1 1 0.
Ein binär angegebener Wert einer Zahl ist in die entsprechende dezimale Form
umzuwandeln. Der dezimale Wert erhält soviele Einsen in aufsteigender Folge
zugeordnet, wie es dem binären Wert entspricht.
2. Lösungsvorschlag
Es werden 4 Neuronen in der Eingabeschicht zur Aufnahme der Binärzahlen und 9
Neuronen der Ausgabeschicht zur Ausgabe der Dezimalzahlen benötigt. Aus der
Aufgabenstellung ergeben sich folgende Trainingsmusterpaare:
Zahl
0
1
2
3
4
5
6
7
8
9
Eingabe
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
Ziel
000000000
100000000
110000000
111000000
111100000
111110000
111111000
111111100
111111110
111111111
3. Das Applet
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/fi2/Perz.html
62
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.4.6 Adaline und Madaline
2.3.4.6.1 Adaline-Modell
1. Grundlagen
Das ADALINE23-Modell wurde zwischen 1956 und 1960 von B. Widrow und M. Hoff
entwickelt. Es ist ein einschichtiges "feedforward"-Netz mit binären
Schwellwertelementen. Die Elemente können in Abhängigkeit vom summierten
Input, den Output +1 oder -1 haben (Signumfunktion). Das Netzwerk umfaßt 2
Schichten: Eingabe- und Adaline-Schicht:
......
1
Eingabeschicht
Adalineschicht
Abb. 2.3-6: Topologie des Adaline-Netzes
Das Adaline war in Hardware mit physikalischen Schaltern, Potentiometern und
analogen Messgeräten implementiert, also ein Analogrechner:
Eingaben
w2
x2
w1

y
x1
w0
Sprungfunktion
x0
(Zusatz zum Perzeptron)
Lernalgorithmus
Desired Output
Abb.: Analogrechner "Adaline"
Die Stärke des Adaline gegenüber einem Perzeptron-Neuron ist es, dass schon vor
der Sprungfunktion das Signal abgefangen wird und somit ein besseres Einstellen
der Gewichte möglich ist. Die Ausgabe nach der Sprungfunktion wird zum Setzen
eines Flag benutzt, ob das Adaline lernen soll oder nicht, u.U auch mit der
Hebbschen Regel ( wi    xi  y )
23
Adaptive Linear Neuron
63
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Delta-Regel
i  ti  ai
Die Berechnung des Fehlersignals benutzt nicht den tatsächlichen Output oi sondern
die Aktivität ai
Die Anpassung der Gewichte erfolgt dann nach folgendem Gesetz:

wij (t  1)  wij (t )   i  o j
n
 : Lernrate (>0)
n: Zahl der Eingänge (d.h. Gewichte) der Einheit i
Jedes Adaline-Element lernt solange bis seine Aktivität den Wert der gewünschten
Ausgabe hat.
Man kann beweisen, daß die Delta-Regel bei linearer Transferfunktion die Summe
der Fehlerquadrate  i2 minimiert.
3. Berechnung des Adaline-Netzwerks
Lineare Trennbarkeit ist die Voraussetzung für die Konvergenz zur Lösung.
Eingaben
Gewichte
(+)
Schwellenwertfunktion
Abb. 2.3-7: Das Adaline-Element
Jedes Element i muß folgende Gleichung lösen:
w0  BIAS  w1  i1  w2  i2 ...  wn  in  oi
Das Gleichungssystem ist für n linear unabhängige Eingabevektoren (Muster) lösbar.
Die Delta-Regel garantiert das Auffinden einer Lösung. Für mehr als n Muster
entsteht ein überbestimmtes lineares Gleichungssystem. Für ein solches System
kann ein Adaline-Element (Voraussetzung: lineare Trennbarkeit) eine
Näherungslösung durch Minimierung der Summe der Fehlerquadrate finden. Die
Konvergenz gelingt allerdings nur, falls die Lernrate deutlich kleiner als (z.B. 0.2)
gehalten wird.
64
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Konvergenz des Lernverfahrens
Man kann zeigen, daß die folgende Funktion (Summe aller Fehlerquadrate über die
Testmuster 1..p)
E
1
   ( tip  ai ) 2
2 p i
bei jedem Lernschritt kleiner wird und im Grenzwert gegen 0 konvergiert.
5. Applet: Musterassoziator mit einem Adaline-Netzwerk
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/fi-ad/addemo.html
2.3.4.6.2 Madaline-Modell
1. Netzstruktur
Das Modell entsteht aus einem Adaline-Netz durch Hinzufügen eines weiteren
Ausgabeelements:
Eingabeschicht "j"
Adaline-Prozessorelemente "i"
Madalineschicht (Ausgabe) "h"
Abb. 2.3-8: Topologie des Madaline-Netzes
Die obere Ebene ist die eines Adaline-Netzes mit Gewichten wij und einem evtl Bias.
In der nachfolgenden Ebene gibt es von jedem (versteckten Knoten) genau einen
Weg mit Gewicht 1 zum Ausgabeelement. Hier gibt es kein "Bias".
65
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Lernen im Madaline-Netzwerk
Die sich verändernden (lernenden) Gewichte sind die Gewichte der AdalineElemente. Die Veränderung der Gewichte folgt nach der gleichen Formel wie beim
Adaline-Netzwerk. Gelernt wird nur dann, wenn ein Madaline-Element nicht die
gewünschte Ausgabe hat. Für jedes falsch klassifizierte Madaline-Element werden
die Gewichte des zu ihm führenden Adaline-Elements "i" angepaßt, dessen
Aktivitäten am dichtesten bei Null liegt und das falsche Vorzeichen hat.
Falls "ai" die Aktivität des lernenden Adaline-Elements ist und "th" die gewünschte
Aktivität des mit diesem Element verbundenen Madaline-Elements ist, dann suche
unter den folgenden (verdeckten) Knoten i:
net i ist am kleinsten von allen Prozessorelementen (PEs), die mit PEh verbunden sind
ai hat ein falsches Vorzeichen.
t h  oi  0.0
Anschließend berechne, falls die angegebenen

wij   t h  net i   o j
ni
In allen anderen Fällen setze: wij  0.0
i
j
oi
th
ni

Bedingungen
erfüllt
sind
Nummer des aktuellen Prozeßelements
Nummer eines Prozeßelements, das mit dem aktuellen Prozeßelement verbunden ist
Ausgabe des PEi
Zielausgabe des PEi
Anzahl der Eingänge von Prozesselement i
Lernkonstante
Das Netzwerk lernt dadurch in der (verborgenen) Adaline-Schicht eine Art der
internen Repräsentation der Eingabevektoren, die dann durch die MadalineElemente klassifiziert wird. Die Lernregel, die die Kenntnis der gewünschten
Ausgabe voraussetzt, wird auf die verdeckte Schicht angewandt.
Die Ausgabeschicht darf auch mehr als ein Element enthalten. Allerdings darf jedes
Element der verdeckten Schicht nur einen Ausgang besitzen, da sonst die Lernregel
nicht sinnvoll angewendet werden kann.
66
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.4.7 Linear separierbare Probleme
Lineare Separierbarkeit
Ein einzelnes Perzeptron teilt den Eingangsraum mit einer Ebene in zwei Teile. Im
zweidimesionalen Raum sind diese Ebenen Geraden, im dreidimensionalen Raum
Flächen usw.
Abb.: Lineare Trennbarkeit in zweidimensionalen Raum
Man diese Ebene erlernen lassen. Falls die Ausgabe des Perzeptrons nicht der
gewünschten Ausgabe entspricht, kann man die Gewichte durch Aufaddieren von
wi lernen lassen Im zweidimensionale Fall hat die separierende Gerade folgende
Formel: w1 x1  w2 x2  w0  0 . Daraus ergibt sich die folgende normale
Geradengleichung (umgestellt nach x 2 )
x2  
w
w1
x1  0
w2
w2
Linear separierbare Probleme lassen sich offensichtlich durch eine Gerade
(Hyperebene) in zwei Klassen teilen. Eine solche Hyperebene lässt sich definieren
    

durch  z |  w z   b  0 . Die eine Halbebene ist dann definiert durch

 

    

    

 z |  w z   b  0 , die andere durch  z |  w z   b  0 . Klassifikationsmechanismen


 

 

dieser Art werden auch Perceptrons genannt. Für viele separierbare Probleme kann
eine Hyperebene auf verschiedene Art und Weise erstellet werden, z.B.:
67
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Abb.:
Viele Ebenen separieren nicht gerade klug. Legt man die Ebene an einen Rand,
dann können leicht Muster auftauchen, die die Ebenen überschreiten. Deshalb
versucht man eine Ebene mit einem möglichst breiten Korridor drumherum
auszustatten.
Linear separierbare Probleme mit Korridor
Im vorliegenden Fall wurden 2 Klassen 1 und  2 betrachtet, die sich linear trennen
lassen:
 1  xi  1
yi  
 1 xi  2
Gesucht ist aber jetzt die optimale Trennfunktion, die die Summe der Distanzen zu

den beiden Klassen maximiert. Die trennende Hyperebene wx  b  0 ist (zu diesem
Zweck) definiert durch

- w (Vektor der senkrecht auf der Hyperebene steht
- b (Skalar, der mit dem Abstand der Hyperebene vom Ursprung des Koordinatensystems
korrespondiert. Der Abstand ist gleich
b


, wobei
w 
2
w
i 1
w
i
2
die Länge des Vektors ist.
Der Abstand eines Punkts x von der Hyperebene ist gegeben durch
 
w x  b
d ( w ,b ) 
.

w


Die Parameter w und b der Trennfunktion wx  b  0 sind nicht eindeutig bestimmt.
Es wird angenommen, dass folgendes gilt:
68
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen


min wxi  b  min wxi  b  1
xi 1
xi  2
Das ist gleichbedeutend mit

yi  wxi  b  1
Falls die letzten beiden Bedingungen gelten, liegt die Hyperebene in kanonischer
Form vor.
1

w
    

 z |  w z   b  1

 

    

 z |  w z   b  1

 

    

 z |  w z   b  0

 

Der Korridor soll möglichst breit werden
Abb.: Hyperebene in kanonischer Form mit möglichst breitem Korridor (margin)

w und b können so eingestellt werden, dass alle Punkte außerhalb des Korridors

  
liegen und die Support Vectors genau auf der Grenze: min  w xi   b  1 . Falls z 1
i 1... l 


und z 2 die Support Vectors sind, dann gilt:
-
 
 w z1   b  1


 


 w z 2   b  1


     
 w  z 1  z 2    2

 
Normieren führt zu
69
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen

w   2
 z1  z 2   

 w
w 

w   2
Daraus erhält man ein passendes w :   z1  z 2     0
 w
w 

Die zugehörige Entscheidungsfunktion ist: f

w ,b
    
 sgn   w xi   b   yi
 


Der Abstand von z 2 zur Hyperebene beträgt: d ( w ,b ) 
 
w  z2  b  1

. Durch Einsetzen
w

2
von wz 2  b  1 erhält man 
w

Der Abstand von z1 zur Hyperbene beträgt: d ( w ,b ) 
 
w  z1  b  1

. Durch Einsetzen
w

2
von wz1  b  1 erhält man 
w


Somit gilt: m arg in  d ( w ,b 1) ( z 1 )  d ( w ,b 1) ( z 2 ) 
2

w
Damit ist das Auffinden der optimalen Hyperebene, welche die Größe margin
maximiert, äquivalent zur Lösung des folgenden Problems:

Finde diejenigen Parameter w und
- m arg in 
2

b , die
maximieren unter der Bedingung
w

- y i ( w x i  b)  1 (i = 1, 2, ... ,N)
Das Problem lässt sich mit Hilfe verschiedener Optimierungsmethoden lösen, z.B.
durch quadratische Optimierung.
Den Rand (margin) zu maximieren ist identisch mit der Forderung: "die

1 
1  2
w .
Ebenenvektorlänge w zu minimieren bzw. w oder
2
2
2
2
2
2
2
2
2
2
w  w1  w2  ...  wn  w1  w2  ...  wn
70
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
 
1  2
1  
w  w  w , weil w  w  w1  w1  w2  w2  ...  wn wn ist.
2
2
Somit ist das folgende Optimierungsproblen zu lösen:
Gegeben ist ein linear trennbare Trainingsmenge


(( x1 , y1 ),..., ( xl , yl ))
1  2
w unter den Nebenbedingungen
2


wxi  b  1 für yi  1 und wxi  b  1 für yi  1
Minimiere
Das Problem ist ein quadratisches Optimierungsproblem mit linearen
Einschränkugen (constraints). Das Problem kann gelöst werden unter Einsatz vom
Lagrange-Multiplikatoren und dem Dualitätstheorem zu Optimierungsproblemen.
Lagrange
2
l
  T  
 
  1 
Die Lagrange–Funktion hat die Form: L w, b,    w    i  yi   w  xi   b   1 .
 
 

 2
i 1

 
 
 i  0 sind die Langrange-Multiplikatoren.
 
Die Lagrange-Methode besagt, daß ( w, b,  ) „geometrisch ausgedrückt“ ein


Satellpunkt der Funktion L( w, b,  ) darstellt.

  
L w,b,   wird minimiert für w und b und maximiert für die  i .24


 
 l

 L( w, b,  )  w   y i i xi  0
w
i 1
l
 

L( w, b,  )   y i i  0
b
i 1
Daraus erhält man:
l


w   y i i x i
i 1
l
0   y i i
i 1
Durch
Einsetzen
in
  
L w,b,  


bekommt
man
das
sog.
2
duale
Problem:
l

   1 
LD  w, b,   w   i  yi  wxi  b   1

 2
i 1
l
l
l
l

 

1
1 l
  i j yi y j x i x j   i j yi y j   i   i   i j yi y j xi x j  W  
2 i , j 1
2 i , j 1
i , j 1
i 1
i 1
l
 T  
1 l
 l


0

y i i


0
bzw. W       i     i j y i y j xi  x j mit i
und



2 i , j 1
  i 1
i

1


24
die alle nichtnegative reelle Zahlen sein müssen
71
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Das Ziel besteht im Auffinden
Optimierungsproblem lösen.
Maximiere
mit
i  0
der
Parameter

 *,
die
das
 T  
1 l
 l
W     i    i j yi y j  xi  x j  unter den Randbedingungen
2 i , j 1
  i 1


folgende
l
y
i 1
i
i
0
 l

 T  

Die Decision Function wäre dann: f  x   sgn    i y i  xi  x j   b  .
 


 i 1


Hat man die optimalen Werte für W ( ) ermittelt, so ergeben sich die Gewichte durch


w    i  yi x .
Das Bias b wird folgendermaßen ermittelt: Man wählt irgendeinen Support-Vektor
 
und setzt ein in wT  x  b  1 . Daraus ergibt sich b .

Die Trainingsvektoren xi gehen in die Formel nur in der Form parametrisierter
 
Skalarprodukte xiT  x j ein.
Support Vectors
 
In einem Sattelpunkt ( w, b,  ) muß notwendigerweise (für alle i) die Kuhn-KarushTucker Bedingung gelten:
*
*
 l

*
 L( w , b,  )  w   y i i xi  0
w
i 1
l
* * *

*
L ( w , b ,  )   y i i  0
b
i 1
* 
*
y i w  xi  b  1  0

i  0
 


 
 i y i w*  x  b *  1  0
Die Zusatzterme der Lagrange-Funktion, die die Randbedingungen repräsentieren,
sind in einem Sattelpunkt gleich 0.
Die Kuhn-Tucker Bedingungen sind notwendig und ausreichend zur Bestimmung für

w* , b, . Die Lösung des primalen bzw. dualen
eine Lösung von
Optimierungsproblems ist äquivalent zur Bestimmung einer Lösung für die KuhnTucker Bedingungen. Für die SVM folgt daraus, dass für einen gegebenen Punkt der


Trainingsmenge xi der Lagrange-Multiplikator entweder  i Null ist oder, falls

ungleich Null, xi eine in dem marg in -Hyperebenen-Bereich (H1 oder H2)liegt.
 
w  xi  b  1
 
H2: w  xi  b  1
H1:
72
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Die Vekoren, die auf H1 und H2 liegen sind die Support Vectors. Sie sind die
l

*
einzigen Punkte, die den optimalen Gewichtsvektor bestimmen: w*   y i i xi .
i 1

Diese Formel kann eingesetzt werden in yi  wxi  b  1  0 und ersetzt das dort das
Ungleichheitszeichen durch das Gleichheitszeichen (liegt innerhalb des margin). b
kann nun berechnet werden.
Numerisch sicherer ist allerdings die Bestimmung eines mittleren Werts:
b 
*


 
max yi  1 w*  xi  min
yi 1
 w
*

 xi

2

Nach dem Erlernen der Hyperebenen-Parameter w* und b * mit der Trainingsmenge,

können bisher noch nicht betrachtete Datenpunkte z klassifiziert werden. Die
gefundene Hyperebene teilt den Raum, dem die zu klassifizierenden Daten
 
 
w*  x  b *  0
w*  x  b *  0 .
angehören
in
2
Bereiche:
und
Die
*

Entscheidungsfunktion, wohin die Datenpunkte z gehören, kann mit w , b * (d.h.mit

*
den support vectors xi unter der Bedingung  i  0 ) so formuliert werden:
 
 
 
 l




* 
f ( z , * , b * )  sgn( w*  z  b * )  sgn   yi i xi  z  b *   sgn   yi i* xi  z  b * 
 i 1

 iSV

2.3.4.8 Nicht linear trennbare Klassifizierer
Die Idee, die deratigen Klassifizierern zugrunde liegt, ist: Abbilden der Eingabedaten
aus dem Eingaberaum in einen Raum mit höherer Dimesion, in dem die Daten linear
getrennt werden können.

X
F
(x)
x
(x)
x
o
(o)
(o)
(o)
x
o
o
(x)
(x)
x
(o)
o
Abb.: Klassifikation mit einer Feature Map
Die Abbildung  (x) bildet den Merkmalraum X (input space) in einen neuen Merkmalraum
 
F  ( x) | x  X  (feature space) ab, der von der Dimension
x  ( x)  (1 ( x),...,  P ( x)) . 1 ( x),...,  P ( x) werden „Features“ genannt.
73
P
ist:
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Hinweis: Eine andere (alternative ) Lösungsmöglichkeit für nicht linear trennbare
Klassifizierer
besteht in der Erweiterung der Perzeptron-Netze zu einem
mehrschichtigen (MultiLayer-) Netzwerk25.
Feature Space
In hohen Dimensionen kann man einfacher trennen.
seperating
hyperplane
Abb.:
Falls das Problem nicht linear trennbar ist, wird das Problem in einen
hochdimensionalen Feature-Space eingebettet:  : x  X  ( x)  F 26
 (feature map) ist eine Abbildung von einem N-dimensionalen Raum in einen M
dimensionalen Raum, z.B. ( x )  x12 , 2 x1 x 2 , x 22 . Die Dimension M des Feature
N  d  1! . (d ist die Ordnung und N die Dimension des
Space ist sehr hoch: M 
d!N  1!
Eingangsraums). Bei d=5 und N=256 ist bspw. M  1010 . Das Problem ist aber, dass
die großen Skalarprodukte, die nun entstehen, gar nicht berechnet werden können.
Das duale Optimierungsproblem nimmt bei Abbildung in einen höher dimensionierten
feature space folgende Gestalt an:

 i    i j yi y j ( x1T )  ( x j )
l
Maximiere
i 1
mit

1
2
l
l


l
unter den Randbedingungen
y
i 1
i 1 j 1
i
i
0
i  0
Nicht die Merkmalvektoren müssen selbst berechnet werden, sondern nur die
paarweisen Skalarprodukte. Die Decision Function nimmt folgende Gestalt an:

 l


f  z   sgn    i yi ( xi )( x j )  b 
 
 i 1

25
vgl.: 2.3.5
Datenpunkte werden zuerst mit einer Funktion  verarbeitet:  :   H , wobei H ein raum ist, in
dem ein Skalarprodukt definiert ist. Dann werden die Punkte  (x) getrennt.
m
26
74
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Ausweg: Statt des Skalarprodukts benutzt man eine sog. Kernelfunktion.
 


K xi , x j     xi    x j 
Kernel Functions
 

 

Definition: Ein Kernel ist eine Funktion, so daß für alle x , z  X K ( x, z )  ( x )  ( z )
gilt, wobei  eine Abbildung von K in einen feature space (inneres Produkt) ist. Die
 


auf K x, z   ( x ) T  ( z ) definierte Funktion heißt Kernel-Funktion. KernelFunktionen müssen die Mercer-Bedingung erfüllen:
 
 
X ist ein endlicher Eingaberaum mit einer symetrischen Funktion K x, z  auf X . Dann ist K x, z 
genau dann eine Kernfunktion, wenn die Matrix K positiv semidefinit ist (, d.h. Keine negativen
Eigenwerte besitzt).
Mit der Kernel Funtion kann man die duale Form und die Decision Function
berechnen:
1 l
 l
 
W       i     i  j y i y j K  xi , x j  .
2 i , j 1
  i 1


l



  
f xi   sgn    i yi K  xi x j   b 


 i 1

Maximiere
Die Decision Function ist
 
Ziel ist eine möglichst einfache Berechnung von K x, z  . Ideal wäre bspw., wenn

 
K x, z  aus x T  z durch Anwendung einer einfachen Funktion k :    berechnet
 
 
werden könnte: K ( x , z )  k ( x , z ) .

Bsp.:  2 ( x )   2 ( x1 , x2 )  x12 , x1 x2 , x2 x1 , x22 .



2
Dann gilt:  2 ( x ) T   2 ( z )  x12 z12  2 x1 x 2 z1 z 2  x 22 z 22  x1 z1  x 2 z 2   k 2 ( x T  z ) mit der


Funktion k 2 ( x)  x 2
Das Beispiel läßt sich verallgemeinern: Ist  d :  n   m die Abbildung, die zu


einem Vektor x den Vektor aller Produkte von jeweils genau d Komponenten von x
bildet, wobei es auf die Ordnung der d Komponenten ankommt und Komponenten
auch mehrfach auftreten dürfen, so ist die zugehörige Kernel-Funktion:
 

 d

K d ( x, z )   d ( x ),  d ( z )  x T  z
Sollen in der Einbettung verschiedene Produkte von d Komponenten, die sich nur in
der Reihenfolge der Indizes ihrer Faktoren unterscheiden (also x1 x2 und x2 x1 )
Nicht mehrfach auftreten, so muß man mit der Wurzel die Vielfachheit der Produkte

skalieren:  2 ' ( x )   2 ' ( x1 , x 2 )  x12 , 2 x1 x 2 , x 22 . Diese Einbettung gibt dieselbe
Kernel-Funktion wie oben.
Will man in der Einbettung   d alle Produkte von maximal d Faktoren (also auch
weniger als d Faktoren) berücksichtigen, wobei verschiedene Ordnungen der Indizes
der Faktoren auch verschiedene solcher Produkte ergeben soll, so definiert dies die
 

 d
 

folgende Kernel-Funktion: K d ( x, z )   d ( x ),  d ( z )  1  x T z  k d x T z .





Kernel-Funktionen dieser Art heißen Polynomkernels.
75

 
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Das auf Kernel-Funktionen abgestimmte Optimierungsproblem kann so formuliert
werden:
Maximiere
 i   i j yi y j k xi , x j  unter den Nebenbedingungen
l
l
i 1
i , j 1
 
l
y
i 1
i
i
 0 mit  i  0
Ein konvex quadratisches Problem mit einer globalen optimalen Lösung, das in
polynomialer Zeit lösbar ist, wird erzeugt.
Bekannte Kernel-Funktionen





-
Polynom-Klassifikation K  z , x  
-
RBF27
-
Sigmoid28
 x  z
  2
  
K  z , x   exp   x  z / 2 2





 c
p


   

  
K  z , x   tanh   z  xi    



 

Polynomialer Kernel
p ist der Grad des Polynoms und c eine nicht negative Konstante (gewöhnlich vom
Wert 1).
x z

 
K  x , z     i i  c 
i  i

p

Der Vektor  wird so gewäht, dass die Mercer-Bedingung erfüllt ist.
Sigmoid
Ein Kernel, der aus der Sigmoid-Funktion gebidet wird, genügt der MercerBedingung für bestimmte Werte von  und  29. Die Verwendung eines sigmoiden
Kernels im Rahmen der Support Vector Machine kann mit einem zwei Schichten

umfassenden Neuronalen Netz verglichen werden. In solchen Netzwerken wird z

 
durch die erste Schicht in den Vektor F  ( F1 ,..., Fn ) mit Fi  tanh  xi  z    

( i  1,..., N )abgebildet. Die Dimension von F ist die Anzahl der sog. Hidden Units. In

der zweiten Schicht wird die gewichtete Summe der Elemente von F berechnet mit
den Gewichten  i
27
vgl. 2.9
vgl. 2.3.5
29 experimentell von Vapnik ermittelt.
28
76
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
F1
1

z
F2
2
y
Feature Space
.
+1/-1
N
.
FN
Abb.: Ein 2 Schichten umfassendes Neurales Netz mit N "hidden units". Die Ausgabe der ersten
Schicht ist
 
 N

Fi  tanh  xi  z     . Die Ausgabe des Netzes ist sgn   y i i Fi  b 
 i 1

  2

  
Radial Basis Function (Gauss'scher Kernel): K  z , x   exp   x  z / 2 2 





definiert die sog. Fensterbreite und kann für diverse Vektoren von
unterschiedlicher Größe sein.
SVMs mit Gauß-Kernel wiesen von der Verarbeitungsweise eine gewisse Ähnlichkeit
mit selbstorganisierenden Netzen30 auf:
Auf einen Eingabevektor reagieren die Neuronen der Eingabeschicht umso stärker, je näher sie

sich an x befinden. Es wird allerdings kein Gewinner ermittelt.
Netze dieser Art heißen Radial Basis Function Netze31.
F1
1

z
F2
2
-b
Feature Space
.
.
M
FM
30
31
Vgl. 2.8
Vgl. 2.9
77
+1/-1
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.4.9 Support Vector Machines
Support Vector Machines kommen aus dem Gebiet des "machine learning" bzw. der
"statistical learning theory". Sie sind ein Ansatz, der mit Hilfe von Kernelfunktionen 32
einige Neuronale Netze zur Mustererkennung und Funktionsapproximation
zusammen fassen kann.
Ziel

Gesucht ist eine Funktion f ( x ,  ) , die alle Beispiele richtig klassifiziert. Binäre
  

Klassifikation ist bspw. an Hyperebenen orientiert: {x :, w  x  b  0} ,   w, b   R n1
bestimmt die Lage der Hyperebenen im n-dimensionalen Raum. Für die "learning
machine" erhält man:
 
 
LM  f ( x, w, b)  sgn( w  x  b)33
Klasse 1
Klasse 2
Abb.: Lineare Trennbarkeit in zweidimensionalen Raum. Sie ist definiert durch
 
w  x  b  0 . Punkte auf der
linken Seite werden Klasse 1, Punkte auf der rechten Seite Klasse 2 zugeordnet.

  w, b   R n1 bestimmt die Lage der Hyperebenen im n-dimensionalen Raum. Die
Wahl des Parameters erfolgt durch Auswahl einer Menge von Trainingsdaten




(Stichprobe): {( x1 , y1 ), ( x2 , y 2 ),..., ( xl , yl )} . xi bezieht sich auf den n-dimensionalen

Raum, y   1,1. Die Stichprobe wird gezogen mit einer Wahrscheinlichkeit Px, y  .
Die Stichprobe ist nicht unbedingt repräsentativ. Ein Klassifiziere von bestimmter
Qualität ist bestimmt durch das Merkmal: gute Generalisierungsfähigkeit.
Risiko

Aus einer Menge von Mustern, die einer Zufallsverteilung P ( x , y ) unterliegen,

werden 'l' Muster gezogen. Das Risiko, dass f ( x ,  ) die Mustermenge nicht


1
separieren kann, kann so formuliert werden: R( )   y  f ( x , ) dP( x ,  ) .
2
32
33
vgl. 2.3.4.8
Linear Learning Machine
78
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen

1
y  f ( x ,  ) : Differenz zwischen der gewünschten Ausgabe und der tatsächlich
2
vorliegenden Antwort.

Die Parameter  sind so zu bestimmen, dass f ( x ,  ) das Risiko über die


Funktionsklassen f ( x ,  ) minmiert. Da P ( x , y ) unbekannt ist, kann der Risikowert
selbst für gegebene  nicht berechnet werden. Das Risiko muß geschätzt werden.

1 l
Das empirische Risiko Remp ( )   y i  f ( xi ,  kann dagegen aus der
2l i 1
gemessenen mittleren Fehlergröße aus den Trainingsdaten der Länge l und
spezieller Wahl von  bestimmt werden. Remp ( ) repräsentiert jedoch nicht immer

R( ) : Es kann sein, dass f ( x ,  ) so schlecht gewählt wurde, dass gerade die
gewählten Muster auf sie passen und keinen Fehler haben. Das ist bspw. bei einer
Tabelle der Fall. Das empirische Risiko ist dann 0, das reale Risiko sehr hoch. Auf
das reale Risiko kann vom empirischen Risiko nur durch Hinzufügen eines
Vertrauensterms geschlossen werden.
Im Rahmen der statistischen Lerntheorie leitete Vapnik folgende Obergrenze einer
Klassifikationsmaschine für die Generalisierungsfähigkeit her, die in 1   Prozent
der Fälle eingehalten wird:
R( )  Remp ( )   (h, l , )
Die obere Grenze ist abhängig vom empirischen Risiko und dem Vertrauensterm
 ( h, l ,  )
- h: VC-Dimension des verwendeten Hypothesenraums
- l: Anzahl der Muster
2l 

 
h log  1  log  
h

4
 (h, l , )  
l
Die VC-Konfidenz wächst monoton mit h
VC-Dimension 34

Die VC-Dimension ist eine Eigenschaft für gegebenen Funktionsklassen f ( x ,  ) :
-

Die VC-Dimension einer Menge von Funktionen f ( x ,  ) ist definiert als die maximale Anzahl
von Trainingspunkten, die durch diese Klasse von Funktionen in allen möglichen Zuordnungen
l
-
34
separiert werden kann(, d.h. l Punkte können auf 2 mögliche Weisen zerschlagen werden
Die VC-Dimension liefert Maße für die Kapazität von Funktionsklassen.
Vapnik, Chevonenkis
79
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Abb.: 3 Punkte, die nicht durch eine Linie verbunden sind, können durch eine gerichtete Hyperebene
im 2-dimensionalen Raum getrennt werden. Bei 4 Punkten im zweidimensionalen Raum ist dies nicht
möglich. Die VC-Dimension ist 3.
Die VC-Dimension eines n-dimensionalen Raums ist n+1. Support Vector Machines ,
die den Gauss'schen Kernel implementieren haben eine unbegrenzte VCDimension. Die VC-Dimendisionen für polynomiale Kerne (Polynome vom Grad p) ist
 p  d l  1
 , d l ist die Dimension des
bestimmt durch den Binomialkoeffizienten: 
p


Raums in dem die Daten liegen. Hier ist die VC-Dimension begrenzt, sie wächst aber
stark mit dem Grad.
80
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.3.5 Multilayer-Netwerk
Aufbau
Perzeptrone zählen lediglich zu den linearen Klassifikatoren. Das reicht 35 oft nicht
aus. Man ist daher übergegangen, mehrere Perzeptrone miteinander zu
verschachten. Man erhält Multilayer Perzeptrone (MLP), die einen wesentlich
mächtigeren Klassifikator darstellen.
X2
X2
X1
Abb. 2.3-9: Eine mögliche Aufteilung einer Punktmenge
mit einen einzelnen Perzeptron
X1
Abb. 2.3-10: Eine mögliche Aufteilung einer Punktmenge mit einem MLP
Ein MLP erstreckt sich über mindestens 3 Schichten36: Eingabe-, Ausgabe und
mindestens eine verborgene Zwischenschicht (hidden layer). Die Eingabeeinheiten
leiten lediglich die Daten an die nächste Schicht weiter. In den Zwischenschichten
findet die eigentliche Verarbeitung / Klassifizierung statt. Die Eingabe- und jede
Zwischenschicht enthält zusätzlich zu den normalen Perzeptronen noch ein Bias,
das immer eine "1" an die nächste Schicht weitergibt und damit den Schwellenwert
auf Null normiert.
Beim MLP handelt es sich um vollverschaltete Netzwerke, d.h. die Ausgänge der
Perzeptrone einer Schicht werden alle mit jedem Perzeptron der nächsten Schicht
verknüpft und damit ein vorwärtsgerichtetes Netz konstruiert. Die Spezifizierung
eines Netzwerks erfolgt über die Parameter:
-
35
36
Anzahl der Schichten
Anzahl der Perzeptrone der einzelnen Schichten
in der Schicht verwendete Aktivierungsfunktion
Hier stehen bspw. lineare Funktionen, Tangenshyperbolicus, Fermifunktion usw. zur Auswahl.
vgl. 2.3.4.4, XOR-Problem
oft auch Layer genannt.
81
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Eingabevektor
1



1


1

Ausgabevektor
Abb. Beispiel für den Aufbau eines MLP
Nomenklatur
Das vorstehende Netz stellt ein vierschichtiges oder dreistufiges Netz dar. Bei
"Stufennomenklatur" wird die Eingabeschicht nicht als Stufe mitgezählt, weil diese
nur die Eingaben weiterleitet.
Die Anzahl der Neuronen wird von der Eingabeschicht an hintereinander
geschrieben. Das vorstehende Netz ist bspw. ein 4 – 3 – 2 – 1 –MLP. Man kann
desweiteren hinter jede Nummer eine Zahl schreiben, die angibt, welche Kennlinie
die Neuronen der jeweiligen Schicht haben. Für das vorstehende Netz bspw. 4L 373T38-2T-1T –MLP39.
universaler Funktionsapproximator
MLPs sind universale Funktionsapproximatoren, d.h. Sie können beliebige Muster
und Funktionen darstellen. Wieviele Neuronen nun für ein bestimmtes Problem
benötigt werden ist nicht klar. Gibt man einem neuronalen Netz zu viele Neuronen,
lernt es sehr schnell auswendig und generalisiert nicht. Hat es zu wenige, wird das
Problem nicht ordentlich gelöst. Die Anzahl der Neuronen in der verborgenen Schicht
ist maßgeblich für die Mächtigkeit eines MLPs. Neuronale Netze mit mehr als einer
Hiddenschicht sind leistungsfähiger als die mit einer Schicht, lernen aber langsamer.
37
Linear
Tangenshyperboloicus
39 Der erste Buchstabe der Aktivierungsfunktion ist Kennbuchstabe
38
82
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Das ein neuronales Netz eine Funktion darstellen kann, heißt noch lange nicht, dass
es sie auch lernen kann. Es kann tiefe Täler in der Fehleroberfläche geben, in die
man aber nicht hineinspringen kann40.
40
vgl. 2.4.2, 2.4
83
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4 Backpropagation Netzwerke
2.4.1 Beschreibung
Zweischichtige Neuronale Netze sind nur mit Einschränkungen zur Abbildung von
Mustern geeignet41 .Backpropagation Netzwerke bestehen aus drei oder mehreren
Neuronenschichten. Die erste Neuronenschicht dient zur Aufnahme von externen
Eingabewerten, die letzte Neuronenschicht ist zur Wiedergabe der Ausgabewerte
vorgesehen. Die inneren Neuronen sind verdeckt ("hidden"). Sie ermöglichen die Lösung von Problemen, die eine interne Aufbereitung von Eingabewerten erfordern.
Bsp.: "Exklusives ODER XOR"42
Eingabe1
0
0
1
1
Eingabe2
0
1
0
1
Ausgabe
0
1
1
0
Neuronale Netze haben die Neigung, auf ähnliche Eingaben auch ähnliche
Ausgaben zu erzeugen. Die XOR-Operation verlangt, daß ausgerechnet die
ähnlichen Eingaben mit unterschiedlichen Ausgaben beantwortet werden müssen.
Schaltet man zwei Netze hintereinander und lehrt beide das XOR-Problem, dann
teilen sich die Netze die Arbeit.
Abb. 2.4-1: Netzstruktur zur Lösung des XOR-Problems
Das erste Netz erzeugt aus der Eingabe einen Zwischencode, das 2. Netz lernt die
richtigen Antworten auf die "heimlichen" Zwischenwerte.
Jedes Neuron einer Schicht ist mit jedem Neuron der vorgelagerten
und
nachfolgenden Schicht verbunden.
Die
Richtung
des
Informationsflusses
verläuft
vorwärtsgerichtet
(Forwardpropagation) von Neuronen der Eingabeschicht über die Neuronen der
Zwischenschicht(en) zu Neuronen der Ausgabeschicht (Feedforward-Netzwerke).
41
42
vgl. 2.3.4
vgl. 2.3.4
84
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Auf diese Weise werden die Werte über ihre gewichteten Verbindungen zu den
Einheiten des Ausgabe- Vektors nach vorn propagiert. Danach vergleicht man den
erhaltenen Ausgabevektor. Die Differenz zwischen tatsächlichem und gewünschtem
Ergebnis ist eine Funktion der aktuellen Verbindungsgewichte. Diese werden mit
Hilfe einer Lernregel, die den Namen Backpropagation43 trägt so angepaßt, daß
sich der Fehler des Systems verkleinert. Von der Ausgangsebene wird der Einfluß
der Ebenen auf alle Fehler zurückgerechnet.
Abb. 2.4-2: Propagation und Backpropagation
Diese Verfahrensweise wird zyklisch für alle Muster wiederholt. bis der Fehler einen
ausreichend kleinen Wert erreicht hat.
Bei diesem Verfahren sind beliebig viele Zwischenschichten möglich, da die
Fehlerkorrektur schrittweise von der Ausgangsebene zur Eingangsebene
vorgenommen wird. Eine zu große Anzahl von Zwischenschichten erfordert mehr
(langsame) Matrizenoperationen ohne einen entsprechenden Gewinn an
Auswahlmöglichkeiten. Eine geringe Anzahl von Zwischenschichten verkleinert den
Rechenaufwand, verhindert aber eine korrekte Mustererkennung.
43
nach: D.E. Rumelhart, G.E. Hinton, R.J. Williams: Learning Internal Representations by Error Propagation
in: David E. Rumelhart, James L. McClelland (Hrsg.) : Parallel Distributed Processing. Explorations in the
Microstructure of Cognition, Volume 1: Foundations, Cambridge (Mass.), The MIT Press
85
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.2 Grundlagen
2.4.2.1 Herleitung des Backpropagation Algorithmus
Ziel des Backpropagation-Lernverfahrens ist: Bestimmen von Verbindungsgewichten
wij mit denen das Netzwerk die vorgegebene Menge von Eingabemustern auf die
entsprechenden Zielmuster möglichst fehlerfrei abbilden kann.
Ein Maß für die Abbildungsfähigkeit (Leistungsfähigkeit) des Netzwerks ist der
mittlere quadratische Fehler über alle Musterpaare (MSE):
(1)
E   E p   (t pk  o pk ) 2
p
p
k
t pk  o pk : Lernfehler eines Ausgabeneurons k für ein vorgegebenes Muster.
Durch das Verändern der einzelnen Verbindungsgewichte wij ändert sich der
Ausgabewert von Neuronen der Ausgabeschicht und damit auch E.
E

W


w'
w' '
Abb. 2.4-3: Energieverlauf
Die Minimierung von E kann über die Verkleinerung der Lernfehler E p für jedes
Muster angestrebt werden, d.h.: Bestimmen solcher wij , die die Lernfehler Ep des
Musters
reduzieren.
Das
Backpropagation-Verfahren
beruht
auf
einem

Gradientenabstiegsverfahren. Im Punkt w ' wird die Tangente auf der MSEOberfläche bestimmt und auf der Tangente um eine gewisse vorgegebene Länge

abgestiegen. Man erhält den Gewichtsvektor w ' ' , bestimmt wieder die Tangente und
wiederholt das Verfahren. Der Backpropagation Algorithmus sucht das Minimum der
Fehlerfunktion eines bestimmten Lernproblems durch Abstieg in der
Gradientenrichtung entlang der Fehlerfunktion. Die Kombination der Gewichte eines
Netzes, die den Berechnungsfehler minimiert, wird als Lösung des Lernproblems
betrachtet. Der Gradient für die Fehlerfunktion muß für alle Punkte des
Gewichtsraums existieren, d.h. die partiellen Ableitungen der Fehlerfunktion nach
den einzelnen Gewichten müssen überall definiert sein.
Der Backpropagation Algorithmus arbeitet in zwei Schritten: Feedforward-Schritt und
Backpropagation Schritt. Im Feedforward Schritt wird am Eingang ein Testmuster
angelegt, und die Ausgabe (Output) berechnet. Aus dem errechneten Output und
der gewünschten Ausgabe wird mit Hilfe der Fehlerfunktion der Fehler berechnet:
86
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
(2)
E   (t k  ok ) 2
k
Der Fehler wird dann im Backpropagation Schritt von der Ausgabeschicht aus auf
die Gewichte der einzelnen Schichten aufgeteilt. Die Gewichte werden dabei so
modifiziert, dass sich der Fehler reduziert.
x1
x2
…
(i)
xni
...
Feedbackward
1
wij
(j)
...
1
w jk
(k)
...
Feedforward
Abb. 2.4-4: Beispiel eines zweistufigen Multilayer-Perzeptrons. In der Feedforward-Richtung wird die Ausgabe
für ein angelegtes Eingangsmuster berechnet. In der Backpropagation-Richtung wird in der Trainingsphase der
fehler am Output auf die Gewichte zwischen den Schichten aufgeteilt.
Am Beginn der Trainingsphase werden alle Gewichte zufällig initialisiert. Im
Feedforward-Schritt wird ein Eingangsmuster angelegt und die Ausgabe des Netzes
berechnet: net j   wij  xi . Die Ausgabe der Neuronen im „j“-Layer ist dann:
i
o j  F (net j ) . Im nächsten Schritt wird die Ausgabe der Schicht k berechnet:
net k   w jk  o j . Die Ausgabe der Neuronen im „k“-Layer ist dann: ok  F (net k ) . Zur
j
1
  (t k  ok ) 2 benutzt. Der Faktor
2 k
½ wurde zur Erleichterung der nachfolgenden Berechnung eingeführt. Zur Korrektur
der Gewichte wählt man
weiteren Berechnung wird die Fehlerfunktion E 
(3) w jk  
E
w jk
(Veränderungen der Verbindungsgewichte sind proportional zur Steigung der
Fehlerfunktion, die Lernrate  ist Proportionalitätsfaktor)
Da ok  F (net k ) und net k   w jk  o j ist, kann mit Hilfe der Kettenregel die partielle
j
Ableitung
E
w jk
ausgedrückt
werden
87
durch:
E
E net k


w jk net k w jk
mit
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
net k


  w jk  o j . Da die partielle Ableitung nur nach einer Komponente der
w jk
w jk j
Summe gebildet wird kann man schreiben:
Mit der Definition  k 
net k


w jk  o j  o j
w jk
w jk
E
folgt nach Einsetzen in Gleichung (3):
net k
(4) w jk     k  o j
Zur Berechnung des Ausdrucks  k  
(5)  k  
E
verwendet man wieder die Kettenregel:
net k
E
E ok


net k
ok net k
Für den ersten Faktor kann man nach Einsetzen der Definition für die Fehlerfunktion
E
 1

(t k  ok ) 2  (t k  ok ) . Für den zweiten Faktor aus Gleichung
schreiben:
ok ok 2
ok
(5) gilt:
 F ' (net k ) . Da als Aktivierungsfunktion die sigmoide Funktion
net k
verwendet wird, kann man schreiben:
ok
 F ' (net k )  F (net k )  (1  F (net k )  ok  (1  ok )
net k
So erhält man für
 k  (t k  ok )  ok  (1  ok )
Eingesetzt in Gleichung (4), erhält man für die Änderung der Gewichte:
(6) w jk    (t k  ok )  ok  (1  ok )  o j
Die Formel gilt allerdings nur für die Gewichte der Neuronen in der Ausgangsschicht.
Für die Gewichte der internen Neuronen setzt man analog an:
(7) wij   
E
E net j
E
  

  
 oi 
wij
net j wij
net j
  (
E o j
E

)  o i    (
)  F ' (net j )  o i     j  o i
o j net j
o j
Ist nur eine interne Schicht vorhanden, entspricht in der vorstehenden Gleichung
E
oi  xi . Da sich der Faktor
nicht direkt berechnen lässt, schreibt man unter
o j
Zuhilfenahme von bekannten oder berechenbaren Ausdrücken an:
88
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
(8)
 E
E
E net k
 

   
o j
o j
net k
k net k
k 

 
 
 o j
w
mk
 om 
E 
  w jk    k  w jk
k
k 
   net
k

Aus (7) und (8) folgt somit:  j  F ' (net j )    k  w jk .
k
Das  eines inneren Neurons kann somit aus den „Deltas“ der Vorgängerschicht
berechnet werden. Beginnt man mit der letzten Schicht, der Ausgangsschicht, kann
man sich aus Gleichung  k  (t k  ok )  ok  (1  ok ) „  k “ berechnen. Anschließend kann
man den Fehler rückwärts propagieren, um die Deltas der inneren Schichten zu
berechnen. Da als Aktivierungsfunktion die sigmoide Funktion44 verwendet wird, gilt
F ' (net j )  F (net j )  (1  F (net j ))  o j  (1  o j )
Somit kann für  j  o j  (1  o j )    k  w jk geschrieben werden. Für die Änderung der
k
Gewichte in der inneren Schicht ergibt sich somit
(9) wij    o j  (1  o j )  oi    k  w jk
k
Für ein Netzwerk mit nur einer inneren Schicht gilt oi  xi .
Zusammenfassung. Die Veränderung der Gewichte erfolgt während des
Lernprozesses mit Hilfe des Backpropagation Algorithmus nach folgenden Formeln:
 k  (t k  ok )  ok  (1  ok ) : w jk     k  o j für die Ausgabeschicht.
 j  o j  (1  o j )    k  w jk : wij     j  oi für die inneren Schichten
k
44
Die Ableitung der sigmoiden Funktion kann einfach als
d  1

f ' ( x) 
dx  1  e  x
ex

 
 f ( x)  (1  f ( x) geschrieben werden.
(1  e  x ) 2

89
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.2.2 Verlauf der Fehlerfunktion
Das Lernverhalten wird durch den Verlauf der Fehlerfunktion entscheidend
beeinflußt. Im ungünstigsten Fall konvergiert der Backpropagation-Lernalgorithmus
gegen einen Wert, der nur in einem bestimmten Bereich der Fehlerfunktion minimal
ist (lokales Minimum).
E
lokale Minima
lokales Minimum
globales Minimum
wij
Abb. 2.4-5: Lokales und absolutes Minimum beim Backpropagation
Da stets eine Gewichtsveränderung in Richtung des steilsten Abstiegs der
Fehlerfunktion erfogt, besteht die Gefahr:
1. Der Fehlerwert oszilliert um ein lokales Minimum
2. Das Tal der Fehlerfunktion kann nicht mehr in Richtung des globalen Fehlerminimums verlassen werden
2.4.2.2.1 Lokale Minima
Es ist ein prinzipielles Problem neuronaler Netze, dass die Fehleroberfläche mit
wachsender Dimensiom des Netzes (d.h. mit wachsender Anzahl von Verbindungen)
immer stärker zerklüftet ist und somit die Wahrscheinlichkeit, in einem lokalen
anstelle des globalen Minimums zu landen, mit wachsender Dimension des Netzes
größer wird.
90
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
E
Globales Minimum





w4
w3
w2
w1
W
Abb. 2.4-6: Lokales Minimum
Wählt man die Schrittweite nicht allzu groß und probiert man ggf. mehrere
verschiedene Initialisierungen der Gewichte aus, so zeigt die Erfahrung, dass
hierdurch in der Regel ein Minimum erreicht wird, das für die konkrete Anwendung
akzeptabel ist.
2.4.2.2.2 Symmetric Breaking
Betrachtet man vollständig ebenenweise verbundene Feedforward-Netze, so darf
man bei der Initialisierung der Gewichte nicht alle gleich groß wählen. Würde man
dies nämlich tun, so lässt sich zeigen, dass durch die Modifikation der Lernregel alle
Gewichte zwischen zwei Schichten stets den gleichen Wert erhalten. Dahei ist es
notwendig, zur Initialisierung der Gewichte zufällige (nicht zu große Werte) zu
nehmen.
Bsp.: Gleich initialisierende Gewichte
Die Gewichte können sich zwar verändern, aber alle um den gleichen Betrag,
wodurch die Symmetrie fest erhalten bleibt.
In der Regel reicht es, die Gewichte mit zufälligen Werten zu initialisieren. Häufig
wird zusätzlich darauf geachtet, dass es kleinere Werte sind, was dem Netz
ermöglicht, sich schneller anzupassen.
91
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.2.2.3 Flache Plateaus
Die Größe der Gewichtsänderung hängt bei dem Gradientenverfahren von dem
Betrag des Gradienten ab. In flachen Plateaus stagniert daher Backpropagation
E

W
Abb. 2.4-6: Flaches Plateau
In einem derartigen Bereich werden besonders viele Iterationsschsritte benötigt. Im
Extremfall ist der Gradient der Nullvektor (Maxima), und es findet überhaupt keine
Gewichtsänderung mehr statt. Außerdem entspricht das Verhalten in einem flachen
Plateau dem Erreichen eines Minimus, so dass zunächst nicht erkannt werden kann,
um welche Situaltion es sich handelt.
92
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.2.2.4 Oszillation
Direktes Oszillieren
In unglücklichen Situationen kann das Verfahren oszillieren. Dies geschieht, wenn
der Gradient am Rande einer Schlucht so groß ist, dass durch die
Gewichtsänderung ein Sprung auf die gegenüberliegende Seite der Schlucht erfolgt.
Ist die Schlucht dort genauso steil, bewirkt dies einen Sprung zurück zum
Ausgangspunkt, da der Gradient jetrzt den gleichen Betrag, aber genau das
umgekehrte Vorzeichen besitzt.
E
-


W
Abb. 2.4-7: Direktes Oszillieren
Dieser Effekt tritt vor allem bei relativ steilen Schluchten der Fehleroberfläche auf.
Indirektes Oszillieren
E

W
Abb. 2.4-7: Indirektes Oszillieren
93
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.2.2.5 Verlassen guter Minima
Liegt das globale Minimum in einem steilen Tal, kann der Betrag des Gradienten so
groß sein, dass die Gewichtsänderung aus der Umgebung des globalen Minimums
heraus in die Umgebung eines suboptimalen Minimums hinienführen.
E

W
Abb. 2.4-8: Verlassen guter Minima
2.4.2.3 Möglichkeiten zur Behebung der Problemfälle
Man kann den prinzipiellen Problemen, die bei der Anwendung des Backpropagation
Verfahrens auftreten, folgendermaßen begegnen:
-
-
-
45
Die Wahl der Lernrate  (Schrittweite) ist entscheidend für das Verhalten des
Backpropagation-Algorithmus. Wird nach einer vorgegebenen Trainingszeit keine
befriedigende Lerngüte erreicht, so empfiehlt es sich,  zu ändern. Generell bewirkt ein
großes  starke Sprünge auf der Fehleroberfläche und erhöht somit das Risiko, ein globales
Minimum in einem engen Tal zu überspringen. Zu kleine Werte von  bewirken einen spürbar
höheren Zeitaufwand während des Trainings, der in einem falchen Bereich inakzeptabel hoch
werden kann. Da der optimale Werte von  von vielen Faktoren, wie dem Problem, Wahl der
Trainingsdaten, Größe und Topologie des Netzes usw. abhängt, kann es keine generelle
Empfehlung für die Wahl von  geben. Erfahrungen haben gezeigt, dass es sinnvoll sein kann
mit einem höheren Wert von  zu beginnen und ggf. diesen in Schritten von 0.1 zu verringern.
Ein "unglückliche" Initialisierung der Startgewichte kann dazu führen, dass das Verfahren in
einem kritischen Bereich der Fehleroberfläche (z.B. in einem flachen Plateau) startet. Es kann
daher sinnvoll sein, vor einer Änderung der Lernrate zunächst die Lernphase mit einer
geänderten Initialisierung der Startgewichte zu wiederholen.
Es wurden verschiedene Modifikationen45 des Verfahrens entwickelt. Fast allen
Modifikationen ist gemein, dass sie auf Heuristiken beruhen.
z.B. Momentum-Version, Weight Decay, QuickProp
94
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.2.4 Festlegen von Parameterwerten
2.4.2.4.1 Lernrate 
Ein schnelles Absinken des Fehlerwerts kann durch einen möglichst großen Wert
der Lernrate (nahe 1) erreicht werden. Dabei kann aber der Fehlerwert über das
Minimum der Fehlerfunktion hinauslaufen. Im folgenden Lernzyklus ist dann eine
Veränderung des Verbindungsgewichts in genau entgegengesetzter Richtung
erforderlich. Ein wiederholtes Auftreten dieses Effekts führt zu unerwünschten
Schwingungen um das Minimum der Fehlerfunktion. Das Oszillieren kann durch
Berücksichtigung des vorliegenden Werts der Gewichtsveränderung bei der
Berechnung des aktuellen Gewichtsveränderungswerts vermieden werden:
2.4.2.4.2 Momentum
wij (t  1)     j  oi    wij (t ) (10)
Der Faktor  gibt an, wie stark der Wert der alten Gewichtsänderung in die
Berechnung der neuen Gewichtsänderung einfließen soll. Üblicherweise wird beim
Trainieren von Backpropagation-Netzwerken  mit 0.9 und  nahe dem Wert 0.3
gewählt.
2.4.2.4.3 Die Anzahl der inneren Einheiten
Im Allgemeinen steigert die Anzahl verborgener Schichten die Mächtigkeit des
Netzes. Es gibt aber keine Möglichkeit die optimale Anzahl verborgener Schichten
für ein spezielles Problem zu bestimmen. Die Praxis hat gezeigt, dass häufig eine
verborgene Schicht ausreicht.
Auch die optimale Anzahl der Neuronen in einer verborgenen Schicht wird durch das
Problem bestimmt. Generell kann Folgendes über die Anzahl der inneren Einheiten
in einem Backpropagation Netz festgehalten werden:
Anzahl innerer Einheiten zu klein Das Backpropagation Netz kann das Problem nicht lösen.
Anzahl innerer Einheiten zu groß
- Es besteht die Gefahr des Overtraining
- Das Problem wird nur teilweise durch Generalisierung
erkannt
- Die überflüssigen Einheiten sind ausschließlich zur
Erkennung der restlichen Trainingsmuster bestimmt (quasi:
lokale Speicherung)
- Es wird keine grundlegende Ausbildungsvorschrift
gefunden
95
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.2.5 Testphase (Recall)
Die Funktionsweise des Backpropagation-Netzwerks während der Testphase
entspricht der Funktionsweise jedes anderen "Feedforward"-Netzwerks. Der
Eingabevektor wird an die Eingänge angelegt, die Prozessorelemente berechnen
daraus ihre Ausgabe. Ein Eingangsmuster wird angelegt und die Ausgabe des
Netzes berechnet: net j   wij  xi . Die Ausgabe der Neuronen im „j“-Layer ist dann:
i
o j  F (net j ) . Im nächsten Schritt wird die Ausgabe der Schicht k berechnet:
net k   w jk  o j . Die Ausgabe der Neuronen im „k“-Layer ist dann: ok  F (net k ) .
j
Im Rahmen der Testphase liefern Trainingsdaten Stützstellen, über die das
Backpropagation Netz eine Funktion approximiert. Aber auch außerhalb soll das
Netz eine genügende Genauigkeit aufweisen. Diese Eigenschaft wird als
Generaliserungsfähigkeit des Netzes bezeichnet. Die Generalisierungsfähigkeit
wird mit Hilfe einer Testmenge verifiziert, die mit keiner Komponente der
Trainingsmenge übereinstimmt.
2.4.3 Implementierung
2.4.3.1 Lösung des XOR-Problems mit einem Java-Programm46
1. Vereinbarungen
double Epsilon;
// Lernrate
int AnzEingabeschicht = 2;
int AnzZwischenschicht = 2;
int AnzAusgabeschicht = 1;
// Anzahl der Neuronen in der Eingabeschicht
// Anzahl der Neuronen in der Zwischenschicht
// Anzahl der Neuronen in der Ausgabeschicht
int Steps;
// Traningscyclus
double
double
double
double
W_ij[][];
W_jk[][];
Biases_j[];
Biases_k[];
//
//
//
//
Gewichtsmatrix Eingabeschicht(i) - Zwischenschicht(j)
Gewichtsmatrix Zwischenschicht(j) - Ausgabeschicht(k)
Biases von Zwischenschicht(j)
Biases von Ausgabeschicht(k)
double O_i[];
double O_j[];
double O_k[];
// Eingangswerte(i)
// Zwischenwerte(j)
// Ausgangswerte(k)
double D_j[];
double D_k[];
// Fehlerrate(Delta) der Zwischenschicht(j)
// Fehlerrate(Delta) der Ausgabeschicht(k)
double T_k[];
// Gewünschter Output(Target) der Augabeschicht(k)
46
96
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Gedächtnis-Routinen
Die Methode Ruecksetzen() weist den Gewichtsmatrizen (W_ij, W_jk) zufällige
Anfangswerte zwischen 0 und 1 zu. Das gleiche gilt für die Aktivierungsschwellwerte
(Biases) der Neuronen in der Zwischen- und Augabeschicht
(Biases_j,
Biases_k).
public void Ruecksetzen()
{
Steps = 0;
// Rücksetzten der Neuronen
for (int i = 0; i < AnzEingabeschicht; i++){
O_i[i] =0.0;
}
for (int i = 0; i < AnzZwischenschicht; i++){
O_j[i]=0.0;
}
for (int i = 0; i < AnzAusgabeschicht; i++){
O_k[i] =0.0;
}
// Setzen der Gewichte zwischen Eingabeschicht und Zwischenschicht
// auf eine Zufallszahl zwischen 0.0 und 1.0
for (int i = 0; i < AnzZwischenschicht; i++)
{
for (int j = 0; j < AnzEingabeschicht; j++)
{
W_ij[i][j] = ((java.lang.Math.random() * 2)-1);
}
// Setzen der Biaswerte der Zwischenschicht
Biases_j[i] =((java.lang.Math.random() * 2)-1);
}
// Setzen der Gewichte zwischen Zwischenschicht und Ausgabeschicht
// auf eine Zufallszahl zwischen 0.0 und 1.0
for (int i = 0; i < AnzAusgabeschicht; i++)
{
for (int j = 0; j < AnzZwischenschicht; j++)
{
W_jk[i][j] = ((java.lang.Math.random() * 2) -1);
}
// Setzen der Biaswerte der Ausgabeschicht
Biases_k[i] =((java.lang.Math.random() * 2)-1);
}
}
Die logistische Aktivierungsfunktion kann nur Werte zwischen 0 und 1 annehmen.
// Als Aktivierungsfunktion wird hier die sigmoide Funktion verwendet!
public double sigmoid_Aktivieren(double X)
{
return (1/(1+java.lang.Math.exp(-1 * X)));
}
Die generalisierende Delta-Regel ist in den Prozeduren Feedforward und
Feedbackward versteckt.
public void Feedforward()
{
double net_j;
double net_k;
97
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
// ------------ Eingabeschicht -> Zwischenschicht ----------------for (int i=0; i < AnzZwischenschicht; i++)
{
net_j = 0.0;
for (int j=0; j < AnzEingabeschicht; j++)
{
net_j = net_j + (O_i[j] * W_ij[i][j]);
}
O_j[i]= sigmoid_Aktivieren(net_j+Biases_j[i]);
}
// ----------- Zwischenschicht -> Ausgabeschicht ----------------for (int i=0; i < AnzAusgabeschicht; i++)
{
net_k = 0.0;
for (int j=0; j < AnzZwischenschicht; j++)
{
net_k = net_k + (O_j[j] * W_jk[i][j]);
}
O_k[i]= sigmoid_Aktivieren(net_k+Biases_k[i]);
}
}
Nach Ausführung von Feedforward ist noch nichts passiert, was es in anderen
Netzen nicht auch schon gegeben hätte. Danach wird zunächst in der Prozedur
Feedbackward die gewünschte Ausgabe mit der tatsächlich erhaltenen Ausgabe
verglichen. Damit steht ein Delta-Wert für den Ausgang zur Verfügung. Nun müssen
die Gewichte aller Signalverbindungen, die dorthin führen, (in Abhängigkeit von D_k)
geändert werden. Dazu multipliziert man das Delta mit allen Signalen der
Zwischenschicht und ändert die zugehörigen Gewichte proportional zum Ergebnis
(Proportionalitätsfaktor  , vgl. Formel (10) wij (t  1)     j  oi    wij (t ) ).
Gewichtsmatrix W_jk ist danach auf dem neuesten Stand. Es folgt die Berechnung
von Gewichtsmatrix W_ij. Da es für die mittlere Schicht keine Sollwerte gibt,
zieht man das Delta der Ausgabeschicht heran. Dieses wird wie ein normales Signal
mit den Gewichten der mittleren und der letzten Neuronenschicht verrechnet. DeltaWerte der jeweils zuletzt bearbeiteten Schicht müssen in die Bearbeitung
eingebracht werden. Die erweiterte Delta-Regel ist offensichtlich eine rekursive
Bearbeitungsvorschrift.
public void Feedbackward()
{
// Fehlerrate(D_k) für die Ausgabeschicht berechnen
// ---------------------------------------// |
D_k =(T_k - O_k) * O_k * (1 - O_k)
|
// ---------------------------------------for (int i= 0; i < AnzAusgabeschicht; i++)
{
D_k[i] = (T_k[i] - O_k[i]) * O_k[i] * (1 - O_k[i]);
}
// Summe der Gewichte für die Ausgabeschicht berechnen
// ----------------------------------------// | Summe(W_jk) = W_jk + E * D_k * O_k
|
// ----------------------------------------// und neuen Wert fuer die Biases_k berechnen
// ------------------------------------------// | Summe(Biases_k) = Biases_k + E * D_k
|
// ------------------------------------------for (int i= 0; i < AnzAusgabeschicht; i++)
{
98
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
for (int j= 0; j < AnzZwischenschicht; j++)
{
W_jk[i][j] = W_jk[i][j] + (Epsilon * D_k[i] * O_j[j]);
}
Biases_k[i] = Biases_k[i] + (Epsilon * D_k[i]);
}
// Fehlerrate(D_j) für die Zwischenschicht berechnen
// ---------------------------------------------// | D_j = O_j * (1 - O_j) * Summe(D_k * W_jk)
|
// ---------------------------------------------for (int i= 0; i < AnzZwischenschicht; i++)
{
D_j[i]=0;
for (int j= 0; j<AnzAusgabeschicht; j++)
{
D_j[i]=D_j[i] + ( D_k[j] * W_jk[j][i]);
}
D_j[i]=D_j[i] * O_j[i] * (1 - O_j[i]);
}
// Summe der Gewichte für die Zwischenschicht berechnen
// ----------------------------------------// | Summe(W_ij) = W_ij + E * D_j * O_j
|
// ----------------------------------------// und neuen Wert fuer die Biases_j berechnen
// ------------------------------------------// | Summe(Biases_j) = Biases_j + E * D_j
|
// ------------------------------------------for (int i= 0; i < AnzZwischenschicht; i++)
{
for (int j= 0; j<AnzEingabeschicht; j++)
{
W_ij[i][j]= W_ij[i][j] + (Epsilon * D_j[i] * O_i[j]);
}
Biases_j[i] = Biases_j[i] + (Epsilon * D_j[i]);
}
}
Schwellwerte werden genau die Signalgewichte gelernt. Man behandelt einen
Schwellwert wie eine Verbindung von einem Neuron, das ständig das Signal 1 liefert.
Die Methode Lernen() rufen immer wieder die Methoden Feedforward() bzw.
Feedbackward() auf.
public void Lernen()
{
Steps++;
Feedforward();
Feedbackward();
}
99
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3. Schreibtischtest
3.1 Ausgangslage
Die vorliegenden Methoden sollen mit der folgenden Netzkonfiguration getestet
werden, die das XOR-Problem lösen soll:
Abb. 2.4-9: Backpropagation-Netz zur Lösung des XOR-Problems, Ausgangslage
Gewichtsmatrix W_ij, Gewichtsmatrix W_jk erhielten über die Methode
Ruecksetzen() zufällige Anfangswerte zwischen 0 und 1 zugewiesen. Das gilt
auch für die Aktivierungsschwellwerte der mittleren und der letzten Schicht (Biases_j,
Biases_k).
Der Test ordnet den beiden Eingabeelementen das Wertepaar (0,0) zu, das XOR
bestimmt dazu die Lösung 0.
100
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2 Feedforward (vgl. Methode Feedforward())
Abb. 2.4-10: Backpropagation-Netz zur Lösung des XOR-Problems, Ausgangslage
101
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.3 Feedbackward (vgl. Methode Feedbackward())
Abb. 2.4-11: Backpropagation-Netz zur Lösung des XOR-Problems, Endsituation
2.4.3.2 Applet zur Lösung des XOR-Problems mit einem BackpropagationNetzwerk
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/fi/BPXorSim.html
102
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.5 Modifikationen
2.4.5.1 Momentum-Version
Die Idee der Momentum47-Version ist eine Erhöhung der Schrittweite (Lernrate  )
auf flachen Niveaus und eine Reduzierung von  bei „Tälern“. Das soll erreicht
werden durch Einbeziehung des letzten Adaptionsschrittes in die Berechnung der
aktuellen Gewichtsänderung.
wij (t )  1      
t
E (t )
E (t  j )
   wij (t  1)  1         j
wij (t )
wij (t  j )
j 0
E entspricht dem MSE,  dem Momentum und  der Lernrate. wij (t  1)
beschreibt die Gewichtsmodifikation im letzten Schritt. wij (t ) ist der durch  j
exponentiell gewichtete Durchschnitt aller zu diesem Zeitpunkt berechneten
Ableitungen. Das  steuert das Verhalten zwischen der aktuellen Veränderung und
der alten Veränderung von wij . Für   0 entspricht die obige Vorschrift der
verallgemeinerten Delta-Regel.
Die Summe der bis zum Zeitpunkt t  1 berechneten Gewichtsänderungen wird
Momentum genannt. Die exponentielle Gewichtung durch  j bewirkt, dass eine
Ableitung mehr an Bedeutung verliert, da z. B.  j für große j gegen 0 konvergiert.
Durch die Addition des Momentumterms wird dem Verfahren eine gewisse Trägheit
veliehen. Dadurch steigt die Tendenz, die Richtung der Änderung beizubehalten. So
wird es dem Verfahren erleichtert, Minima in steilen Tälern zu erreichen und flache
Plateaus schneller zu überwinden.
2 Implementierungsmöglichkeiten:
a) wij (t )     i (t )  y j (t )    wij (t  1)
b) wij (t )    (1   )   i (t )  y j (t )    wij (t  1)
mit 0    1
-
Beide Varianten bewirken ähnliche Effekte
Variante b) realisiert rekursiven Tiefpass, der die Gewichtsänderung über die Zeit glättet
Variante a) bewirkt Beschleunigung der Konvergenz entlang flacher Plateaus
Die Momentum Version hat zwei Schwächen:
1. Falls alle Ableitungen konstant gleich sind, besitzt die gewichtete Summe eine obere
Schranke. Damit ist die größtmögliche Gewichtsänderung beschränkt.
2. Unterscheiden sich die Vorzeichen, wird w in die falsche Richtung verschoben. Es findet nicht
zwangsläufig ein Gradientenabstieg statt.
47
vgl. 2.4.2.4.2
103
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.5.2 Weight Decay
Ziel: Vermeidung betragsmäßig hoher Gewichte (Parameter)
Hintergrund: Betragsmäßig große Gewichte führen zu stark zerklüftetem
Fehlergebirge, was das Training erschwert und die Performanz u.U. einschränkt.
Idee: Hinzufügen eines Bestrafungsterms (penalty term) zur
1
2
Fehlerfunktion E *  E     mit    wi (penalty term, Summe der quadrierten
2
Gewichtsverte)
E p* E p
Bildung der neuen partiellen Ableitungen liefert:

 wi
wi
wi
Damit lautet die Lernregel: p wij (t )     i (t )  y j (t )    wij (t  1)
Die neue Lernregel adjustiert Parameter und minimiert gleichzeitig die Beträge der
Parameter
Ergebnis:
- weniger zerklüftete Fehlerfunktion:
- geringerer Abhängigkeit des Lernprozesses von den
Initialisierungsparametern
-  bestimmt den Grad, mit dem der penalty term berücksichtigt wird
- typischer Wertebereich: 0.005    0.03
y
.
.
. . . .
. .
.
.
.
.
.
.
.
.
.
. . .
.
.. . .
.
.
.
.
.
.
- Lamda zu klein; Überanpassung an die
Daten; tatsächl. Abildungsfunktion wird
schlecht approximiert
- schlechte Generalisierung
.
..
.
. . .
. .
.
.
.
.
. .
104
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
y
- Lambda optimal; keine
Überanpassung an die Daten;
tatsächl. Abbildungs-funktion wird
nahezu exakt approximiert
- gute Generalisierung
y
- Lambda zu groß; Erzwingen einer zu
glatten Abbildung; tatsächl.
Abbildungs-funktion kann nicht
approximiert werden
- schlechte Generalisierung
Abb. 2.4-12
- Weight Decay gehört zur Familie der Regulierungsverfahren
- Regularisierung soll möglichst glattes und kontinuierliches Mapping sicherstellen
- besonders relvant für Funktionsapproximation
105
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.5.3 Quickprop
Ziel: schnelles Training eines MLP
Zwei riskante Annahmen:
1) die Fehler/weight Kurve hat die Form einer Parabel
2) die Parabeln für jedes Gewicht wij sind unabhängig voneinander48
Lernregel:
wij (t ) 
E (t ) 49
s(t )
 wij (t  1) mit s(t ) 
s(t  1)  s(t )
wij
E
E (t  1)
 s(t  1)
wij
Parabel
E (t )
 s(t )
wij
Scheitel der
Parabel
wij (t  1)
wij (t )
wij
s
dE
dwij
s (t  1)
s (t )
s(t  1)  0
wij
wij (t  1)
wij (t )
Abb. 2.4-12: Bestimmung des Scheitels der angelegten Parabel
48
Diese Annahme ist nicht richtig, aber durch das iterative Einstellen der Gewichte werden die gemachten Fehler
aufgehoben.
49
Steigung des Gradienten
106
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Effekt: Falls die Annahme des lokal quadratischen Verlaufs der Fehlerfunktion erfüllt,
konvergiert Quickprop um Größenordnungen schneller als Standard-ErrorBackpropagation-Algorithmus.
s (t )
Bei der Betrachtung von
lassen sich 4 Fälle unterscheiden:
s (t  1)  s (t )
1. s (t )  s (t  1)
sgn( s(t ))  sgn( s(t  1))
2. s (t )  s (t  1)
sgn( s(t ))  sgn( s(t  1))
3. sgn( s (t ))  sgn( s (t  1))
4. s (t )  s (t  1)
Die aktuelle Steigung ist kleiner als die
vorangegangene Steigung und hat das gleiche
Vorzeichen. Dann erfolgt die Gewichtsänderung
in dieselbe Richtung wie zuvor.
Die aktuelle Steigung ist größer als die
vorangegangene Steigung. In diesem Fall wäre
die Parabel nicht nach oben sondern nach unten
geöffnet. Somit entfernt sich das Verfahren von
dem Minimum.
Die aktuelle Steigung verläuft in
entgegengesetzter Richtung. Das Minimum
würde übersprungen und das Verfahren befindet
sich auf der gegenüberliegenden Seite des Tals.
Im nächsten Schritt wird dann eine Position
zwischen den 2 vorangehenden Positionen auf
der Fehleroberfläche gewählt.
Die aktuelle Steigung ist gleich der
vorangegangenen Steigung. In diesem Fall würde
der Quotient  groß werden bzw. die
Berechnung wegen Division durch 0 abbrechen
2.4.5.4 Resilient Backpropagation
Ziel: Bessere Anpassung des Trainingsprozesses an den lokalen Verlauf des
Fehlergebirges.
Idee:
-
-
für jeden Parameter eigene Schrittweite, die adaptiert wird
Schrittweitenadaption für Parameter w abhängig von Ableitung der Fehlerfunktion E nach w
zum aktuellen und vorhergehenden Zeitschritt
Für Adaption der Schrittweite entscheidend ist

Gradientenrichtung

Nicht der Betrag des Gradienten
Resilient Backpropagation beinhaltet Kombination verschiedener Verfahren:
 ij … Betrag der Gewichtsänderung für Parameter wij
wij … bezeichnet die eigentliche Gewichtsänderung
-
Die beiden o.g. Parameter werden getrennt adaptiert
s ij (t ) bezeichnet Steigung und Ableitung der Fehlerfunktion nach Parameter wij (t ) :
sij (t ) 
-
E
(t )
wij
Der Betrag der Gewichtsänderung berechnet sich nach (Rprop 1) mit 0  

1  :
 ij (t  1)    für sij (t  1)  sij (t )  0

 ij (t )   ij (t  1)    für sij (t  1)  sij (t )  0

 ij (t  1) sonst

-
Sind Vorzeichen der Gradienten zu den Zeitpunkten t und t-1 gleich, wird der Betrag zur
Parameteränderung erhöht, im umgekehrten Fall verringert
107
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
-
Der 3. Fall (Produkt beider Anstiege Null) wird künstlich erzeugt und ist nur algorithmisch
bedeutsam
-
Zum Start der Verfahrens werden alle Beträge der Gewichtsänderung  ij auf Initialwert
-
gesetzt.
Gewichtsänderungen wij hängen ebenfalls nur vom Vorzeichen der Gradienten zum
init
aktuellen und vorhergehenden Zeitschritt ab.
  ij (t ) für sij (t  1)  sij (t )  0  sij (t )  0 Fall 1
  (t ) für s (t  1)  s (t )  0  s (t )  0 Fall 2
 ij
ij
ij
ij
wij (t )  


w
(
t

1
)
für
s
(
t

1
)

s
(
t
)

0
Fall 3
ij
ij
ij

  sgn sij (t )    ij (t ) sonst
Fall 4
-
In den ersten beiden Fällen wird der Betrag abhängig von Gradientenrichtung addiert oder
subtrahiert
Der 3. Fall macht die vorangegangene Gewichtsänderung rückgängig, wenn beim letzten
Trainingsschritt (lokales) Minimum der Fehlerfunktion übersprungen wurde.
Im 3. Fall wird zusätzlich die Steigung s ij (t ) „künstlich“ auf Null gesetzt, weil sich sonst das
-
Vorzeichen der Steigung im nächsten Adaptionsschritt wiederum ändern und der Betrag der
Gewichtsänderung wiederum reduziert werden würde.
Durch diese Modifikation tritt im nächsten Trainingsdurchlauf der 3. Fall von Gleichung (Rprop
1) und der 4. Fall von Gleichung (Rprop 2) ein, bei dem nur das Vorzeichen der aktuellen
Steigung berücksichtigt wird.
-
Typische Parameterwerte:   1.2;   0.5; 0.01   ; 
 1.0  10 ;   50
Die Kombination mit Weight Decay oft sinnvoll, um bessere Generalisierungseigenschaften zu
erreichen


init
108
min
6
max
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
1. Fall
2. Fall
E
t 1
s(t  1)  s(t )  0
s (t )  0
t
E
s(t  1)  s(t )  0
s (t )  0
t 1
w(t  1)
t
w(t  1)
t 1
t 1
w(t )
w(t )

W

W
3. Fall
Fortsetzung vom 3. Fall
E
E
s(t  1)  s(t )  0
s (t )  0
t 1
s(t  1)  s(t )  0
s (t )  0
s(t  1)  0
t 1
t 1
w(t  1)
t 2
t
w(t )
w(t )
w(t  1)
s (t ) : 0

W

W
letzte Änderung zurücknehmen
Abb.2.4-13: Illustration der verschiedenen Fälle
109
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.4.5 Anwendungen
2.4.5.1 Simulator für Backpropagation-Netze
Der Simulator zeigt das Trainieren und Testen folgender Funktionen mit einem
Backpropagation Netz:
http://fbim.fh-regensburg.de/~saj39122/wabrpi/index.html
Logisches UND, logisches ODER, Multiplexer, logisches XOR (Standard), Zwei-BitAddierer.
2.4.5.2 Kreuzprodukt
Dieses Java-Applet erlernt mit Hilfe eines Backpropagation-Netzes, wie man aus
zwei Vektoren das Kreuzprodukt errechnet.
http://fbim.fh-regensburg.de/~saj39122/jkp/index.html
2.4.5.3 BPN-Robot
Das Applet zeigt die Darstellung eines autonomen Roboters mit Hilfe eines
Backpropagation-Netzes
http://fbim.fh-regensburg.de/~saj39122/NN/StellwagPrucha/index.html
110
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.5 Rekurrente Netze
2.5.1 Auto-assoziative Netze
2.5.1.1 Aufbau
Autoassoziatoren bilden eine Klasse verwandter Modelle, bei denen eine
bestimmte Anzahl von Einheiten vollständig miteinander verknüpft sind.

externe Eingabe: x

Ausgabe: x
Abb. 2.5-1: Topologie von Autoassoziator-Netzen
Es können nur solche Verbindungen zwischen Einheiten trainiert werden, deren
Zielvorgabe extern (außerhalb des Netzwerks) spezifiziert ist. Trotz dieser
Einschränkung können Autoassoziatoren lernen, Muster zu vervollständigen bzw.
verdrehte Muster in Originalform wiederherzustellen. Außerdem können sie
trainieren, den Prototyp aus einer Menge Muster auszuwählen, die während der
Trainingsphase präsentiert wurden.
Autoassoziatoren gleichen bis auf eine, aber wesentliche Ausnahme den
Musterassoziatoren. Es gibt nur eine einzelne Menge von Einheiten, keine
Verbindung zwischen Ein- und Ausgabeeinheiten, jede Einheit ist sowohl Eingabe111
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
als auch Ausgabeeinheit und jede Einheit ist mit jeder anderen (u.U. auch mit sich
selbst) verbunden. Eingabemuster sind Vektoren mit positiven und negativen
Eingabevektoren für die Einheiten. "Bias"-Elemente gibt es nicht. Die Einheiten
nehmen dann positive und negative Werte an, die sich durch die Verbindungen
innerhalb des Netzwerks bzw. durch externe Eingabe ergeben.
2.5.1.2 Grundlagen
1. Der lineare Autoassoziator
1.1 Aktivierungsregel
Er ist bestimmt durch folgende Aktivierungsregel (lineare Aktivierungsfunktion):
ai  estr  exteingabei  istr  inteingabei  (1  decay)  ai
"exteingabei" und inteingabei bestimmen die Netzeingabe der Einheit i. "estr" und
"istr" sind Parameter und beeinflussen externe und interne Eingabe.
1.2 Arbeitsweise
Zum Zeitpunkt 0 sind alle Einheiten auf 0 gesetzt. Zu Beginn des 1. Zyklus ist ein
Muster mit Werten von +1 und -1 Eingabe. Beim 1. Durchlaufen des Zyklus nimmt
jede Einheit einen Aktivierungswert ( estr  exteingabe) an. Danach folgt die
Verarbeitung der Ausgabe. Der Einfachheit halber kann "decay" auf 1.0 gesetzt
werden. In diesem Fall ist die Aktivierung jeder Einheit zum Zeitpunkt t gegeben
durch:
(1)
ai (t )  estr  exteingabei (t )  istr  inteingabei (t 1)
"inteingabei" ist festgelegt aus den Aktivierungen zum Zeitpunkt (t-1).
Das lineare Modell neigt dazu sich auszudehnen. Aktivierungen können unbegrenzt
anwachsen.
1.3 Assoziation der Eigenvektoren
Ein linearer Assoziator assoziiert (in aller Regel) einen beliebigen Eingabevektor
(unter gewissen Einschränkungen) mit dem Eigenvektor, der den größten Eigenwert
hat50.

a 0 kann als eine Linearkombination der n Eigenvektoren ausgedrückt werden:
 


a0  1 x1   2 x2  ...   n xn , wobei angenommen wird, dass x1 , x2 ,..., x n die n Eigenvektoren sind und
1 , 2 ,..., n
ihre
Vielfacheinheiten.
Nach
der
ersten
Iteration
ergibt
sich
  


 



daraus: a1  a0W  1 x1   2 x2  ...   n xn W  11 x1   2 2 x2  ...   n n xn . Nach t Iterationen

t
t 
t 
erhält man den Terrm: at   11 x1   2  2 x 2  ...   n n x n
50 Ein n-dimensionanler Vektor
112
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Muster, die in einem Netzwerk skaliert werden, nennt man „Eigenvektoren“.
Eigenvektor bedeutet vereinfacht: „Es ist der gleiche Vektor“. Die Größe des
Eigenvektor, wie er durch das Netzwerk bearbeitet wird, nennt man Eigenwert.
2. Linearer Hebbscher Autoassoziator
2.1 Lernen (Trainieren des Netzwerks)
Das Trainieren des Netzwerks verursacht nach der Hebbschen Regel folgende
Änderungen der Gewichte bei jedem Lernschritt:
wij    exteingabei  exteingabej
(2)
2.2 Test
Es gilt 51

  
ot  k   ol  il  it n
(3)
l
k  n   ( n ist die Anzahl der Einheiten;  ist ein Parameter, der die Größe eines
Lernschritts
bemißt).
 
il  it n : normalisiertes Skalarprodukt
ol kann durch il ersetzt werden (, da während des Trainings der Eingabevektor mit
sich selbst in Beziehung steht).
Aus (3) folgt:
- Falls das Testeingabemuster orthogonal ist zu den Eingabemustern, die während der Trainingsphase
benutzt wurden, dann wird das Netzwerk die Ausgabe 0 erzeugen.
- Falls das Testmuster orthogonal ist zu allen Eingabemustern, die während der Trainingsphase
benutzt wurden, bis auf eine einzige Ausnahme (und die ist identisch zu einem Muster der
Lernphase), dann ist die Ausgabe gleich dem Testmuster multiplizier mit k.
- Falls das gleiche Muster m-mal während der Lernphase präsentiert wurde, dann ist es so, als ob m
Muster im Netz gespeichert sind. Wird dieses Muster beim Test repräsentiert, dann ist die Ausgabe
gleich dem Testmuster multipliziert mit m  k
Wird eine Menge orthogonaler Muster in einem Hebbschen Autoassoziator trainiert
und danach eines der gespeicherten Muster aufgerufen, dann ist die Ausgabe eine
skalierte Version der Eingabe. Der Skalierungsfaktor ist proportional zu der Anzahl
von Tests mit der das Muster während der Testphase präsentiert wird.
Muster, die durch das Netzwerk skaliert werden, heißen Eigenvektoren.
Eigenvektoren unterscheiden sich nur durch einen Faktor, den Eigenwert, vom
Muster während der Lernphase. Die erlernten orthogonalen Muster des Hebbschen
Autoassoziators bilden eine Menge solcher Eigenvektoren. Ihre Werte sind k  ml ( ml
ist die Anzahl der Präsentationen während der Lernphase).
Da
1
der größte Eigenwert ist, dominiert er in der Potenzierung und das bedeutet: Ein beliebiger Vektor
wird in die Richtung des Eigenvektors
51

x1 gezogen, sofern  1 nicht Null und der Eigenwert 1 positiv ist.
vgl. 2.3.2 Präsentation mehrerer Muster während der Trainingsphase
113

a0
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Zu der durch die interne Aktivierung hervorgerufenen Ausgabe (vgl. (3)) kommt noch
weiterhin anstehende externe Eingabe, da beim linearen Autoausoziator mindestens
zwei Zyklen durchlaufen werden müssen (vgl. (1)).
2.3 Beispiele
2.3.1 Beispiel 1
Gegeben sind die beiden Eingabemuster:

i  (1, 1,1, 1,1,1, 1, 1)
1

i 2  (1,1, 1, 1, 1,1, 1,1)
Trainieren des Eingabemusters: Die Gewichte bestimmen sich nach Formel (2)
wij    exteingabei  exteingabej während der Lernphase zu:
1. Schritt
0.125
-0.125
0.125
-0.125
0.125
0.125
-0.125
-0.125
-0.125
0.125
-0.125
0.125
.......
.......
.......
.......
0.125
-0.125
0.125
-0.125
-0.125
0.125
-0.125
0.125
0.125
-0.125
0.125
-0.125
0.125
-0.125
0.125
-0.125
-0.125
0.125
-0.125
0.125
-0.125
0.125
-0.125
0.125
0
-0.25
0.25
-0.25
0
0
0
-0.25
0.25
0.25
0
0
-0.25
0
0
0
0.25
-0.25
2. Schritt
0.25
0
0
-0.25
0
0.25
-0.25
0
0
0.25
-0.25
....
....
....
....
....
Test: Der Test mit dem 1. Eingabemuster ergibt nach den Formeln(1) bzw. (3):

o t1  (2, 2, 2, 2, 2, 2, 2, 2)
Das 1. Eingabemuster ist orthogonal zum 2. Eingabemuster. Der Test mit dem 2.
Eingabemuster ergibt nach den Formeln (1) und (3):

o t2  (2, 2, 2, 2, 2, 2, 2, 2)
2.3.2 Beispiel 2
Gegeben sind 4 Eingabemuster (Ausgangspunkt: Gewichtsmatrix vom 1. Bsp.)

i  (1, 1,1, 1,1,1, 1, 1)
1

i 2  (1,1, 1, 1, 1,1, 1,1)
114
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen

i 3  (1,1,1,1, 1, 1, 1, 1)

i 4  (1, 1, 1,1,1, 1, 1,1)
Trainieren der Eingabemuster: Die Gewichte bestimmen sich nach Formel (2)
wij    exteingabei  exteingabej während der Lernphase zu:
1. Schritt
0.375
-0.125
0.125
-0.375
......
......
......
......
-0.125
0.375
-0.375
..........
0.125
-0.375
0.375
........
-0.375
0.125
-0.125
..........
0.125
-0.375
0.375
........
0.375
-0.125
0.125
.........
-0.375
0.125
-0.125
..........
-0.125
0.375
0.375
.........
0
-0.5
0.5
........
-0.5
0
0
..........
0
0.5
0.5
........
0.5
0
0
.........
-0.5
0
0
..........
0
0.5
-0.5
.........
0.125
-0.375
0.625
........
-0.375
0.125
0.125
..........
-0.125
-0.625
0.375
........
0.375
-0.125
-0.125
.........
-0.625
-0.125
0.125
..........
-0.125
0.375
-0.625
.........
0
-0.25
0.75
........
0.25
0
0
..........
0
-0.75
0.25
........
0.25
0
0
.........
-0.75
0
0
..........
0
0.25
-0.75
.........
2. Schritt
0.5
0
0
-0.5
0
0.5
-0.5
0
0
0.5
-0.5
..........
3. Schritt
0.625
0.125
0.125
-0.375
-0.125
0.375
-0.625
-0.125
0.125
0.625
-0.375
..........
4. Schritt
0.75
0
0
-0.25
0
0.25
-0.75
0
0
0.75
-0.25
..........
Test:

o t1  (3, 3, 3, 3, 3, 3, 3, 3)

o t2  (3, 3, 3, 3, 3, 3, 3, 3)
115
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen

o t3  (2, 2, 2, 2, 2, 2, 2, 2)

o t4  (2, 2, 2, 2, 2, 2, 2, 2)

Erfolgt der Test mit dem Eingabemuster ( 1 o t4 ) , dann ist

o t  ( 2, 2, 2, 2, 2, 2, 2, 2)
Jedes Muster ist hier ein Eigenvektor des Netzwerks. Der Eigenwert ist gegeben
durch k  ml ( ml ist die Anzahl der Präsentationen während der Lernphase).
2.3.3 Beispiel 3
Das lineare Modell neigt dazu, sich auszudehnen. Eine Erhöhung der Anzahl der
Zyklen von 2 auf 4 führt zu folgenden Aktivierungen:

1. Testmuster i 1  (1, 1,1, 1,1,1, 1, 1)
Im 1. Zyklus ist die Aktivierung: (1, 1,1, 1,1,1, 1, 1)
Im 2. Zyklus ist die Aktivierung: (2, 2, 2, 2, 2, 2, 2, 2)
Hinzu kommt noch die externe Eingabe: (3, 3, 3, 3, 3, 3, 3, 3)
Im 3. Zyklus wird diese Aktivierung wieder mit dem Eigenwert 2 multipliziert:
(6, 6, 6, 6, 6, 6, 6, 6) . Das ergibt mit der anstehenden Eingabe im linearen
Autoassoziator: (7, 7, 7, 7, 7, 7, 7, 7)
Im 4. Zyklus wird diese Aktivierung wieder mit dem Eigenwert 2 multipliziert:
(14, 14,14, 14,14,14, 14, 14) . Hinzu kommt noch die weiterhin extern anstehende
Eingabe: (15, 15,15, 15,15,15, 15, 15)
Die übrigen Muster und die zugehörige Aktivierung lassen sich auf analoge Weise
ableiten.
2. Testmuster

o t2  (15,15, 15, 15, 15,15, 15,15)
3. Testmuster bzw. 4. Testmuster


o t3  ( 4, 4, 4, 4, 4, 4, 4, 4) bzw. o t4  ( 4, 4, 4, 4, 4, 4, 4, 4)
116
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Delta-Regel
Das externe Eingabemuster wirkt einmal zu Beginn des Zyklus. Die Verarbeitung
durchläuft mehrere Zyklen. Nach dem Ende der zyklischen Durchläufe werden die
Gewichte ausgerichtet anhand des festgestellten Fehlers:
fehleri = exteingabei - inteingabei
"inteingabei" ist bestimmt durch mehrmaliges Durchlaufen des Zyklus, im
wesentlichen bestimmt durch die Aktivierungen am Ende des vorangegangenen
Zyklus.
Generell ist in Autoassoziatoren jede Einheit mit jeder anderen Einheit verbunden,
auch mit sich selbst. In Netzwerken mit einer sehr großen Anzahl von Einheiten sind
die "Selbstverbindungen" uninteressant. In kleineren Systemen, die mit Hilfe der
Delta-Regel implementiert sind, können starke Selbstverbindungen das Lernen
besiegen. Selbstverbindungen ermöglichen den Einheiten ihre eigenen
Verbindungen vorzuziehen, So reduziert sich der Fehler. Behindert wird aber die
Stärke des Lernprozesses, der über die Verbindung mit anderen Einheiten realisiert
ist.
117
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.5.1.3 Das "Brain-State-in-the-Box"-Modell
Das Brain-State-In-A-Box (BSB) Modell wurde 1977 von Anderson, Silverstein, Ritz
und Jones eingeführt und ist ein einfaches nichtlineare Netzwerk, das einen
Modellierungsversuch der Assoziationsfähigkeit des menschlichen Gehirns darstellt.
Das BSB ist vollständig vernetzt:
-
Zwei Knoten können für beide Übertragungsrichtungen unterschiedlich gewichtete
Verbindungen haben
ein Knoten kann mit sich selbst verbunden sein (direkte Rückkopplung)

Das BSB-Modell ist ein autoassoziatives Netz, bei dem eine Matrix W gesucht wird,
 
die folgende Gleichung erfüllt: XW  X . Diese rein lineare Berechnung ist jedoch für
den praktischen Gebrauch nicht nutzbar.
Das BSB-Modell hält die Aktivierungswerte in Grenzen. Aktivierungen werden nicht
größer als K bzw. nicht kleiner als -K (üblich ist K = 1.0). So sind die Aktivierungen
quasi in einer Box eingeschlossen. Die Verarbeitung führt dazu, daß Muster zu den
Kanten der Box52 drängen. Kanten entsprechen dann Mustern, die erlernt wurden.
Gestörte und verdrehte Muster treiben dann auf die Werte der gespeicherten Muster
zu (mit dem Nebeneffekt: Vervollständigung und Wiederherstellung der Muster).
Die Eckpunkte des Hyper-Würfels repräsentieren dabei die möglichen Zielzustände,
in die ein Eigenvektor durch genügend viele Iterationen überführt werden kann. Die
möglichen Zielzustände in einem dreidimensionalen Fall wären demnach: (-1,-1,-1),
(-1,-1,1), (-1,1,1),(+1,-1,-1),(+1,-1,+1),(+1,+1,-1),(+1,+1,+1)
Allerdings hängt es von der Gewichtsstruktur des Netzes ab, welche Eckpunkte
verarbeitet werden. Daraus ergeben sich folgende Eigenschaften für das BSBModell:
-
-
die Menge der zulässigen Eingaben liegt in einem limitierten Kontinuum von
 1  ai  1 , so
dass der durch die zulässigen Eingabevektoren aufgespannte Raum durch –1 und 1 begrenz
ist.
die Aktivierung des BSB-Netzes wird über mehrere Aktivierungszyklen kummuliert, so dass
unabhängig von der Gewichtung der Verbindungen eine der Ecken des Hyperkubus erreicht
wird.
Die
Aktivierung
ist
bestimmt
durch
53
ai (t )  estr  exteingabei (t )  istr  inteingabei (t 1) .

Die Limitierungsfunktion hat zum Ziel den Vektor x für den nächsten Schritt zu
berechnen und gegebenenfalls auf die Grenzen –1 und +1 zu kürzen. Unter diesen
Umständen ist es angebracht mit schwächeren Einwirkungen (estr = 0.1) zu
rechnen.
Die Power-Methode



Eine Matrix W wird mit dem Eigenvektor54 v0 multipliziert. Die Ausgabe v1 wird

wiederum mit W multipliziert. Durch die ständige Wiederholung dieses Vorgangs
richtet sich der anfangs eingegebene Vektor in eine Richtung besonders aus,
52
53
54
Hyper-Würfel
vgl. 2.5.2

Der Eigenvektor x einer quadratischen Matrix ist der Lösungsvektor, der die Gleichung
(Eigenwertgleichung) erfüllt
118


Ax  x
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
 

nämlich nach dem Eigenvektor mit dem größten Eigenwert. Falls e1 , e2 ,..., en die


Eigenvektoren einer Matrix sind, dann lässt sich v0 auch schreiben als  i ei ,
wobei
die
gewichteten
Koeffizienten
sind.
Daraus
folgt:
i






v1  Av0  A i ei   i i ei ( i : Eigenwert für Eigenvektor e i ). Das Verhältnis
zwischen 2 Komponenten i und j des Vektor beträgt demnach:
 i i
. Nach n
 j j
n
    
Iterationen wird ersichtlich, dass sich der Faktor  potenziert:  i  i  . Da sich in
    
 j  j 
der Praxis unter allen Umständen zwei Eigenwerte finden lassen, für die gilt i   j
wächst das Verhältnis zwischen den Eigenwerten über alle Grenzen, d.h.: Der
Eigenvektor mit dem größten Eigenwert (dominanter Eigenwervektor) wird sich bei
entsprechend vielen Iterationen am stärksten durchsetzen.
Durch dieses Verffahren lassen sich Eigenwerte für eine beliebige Genauigkeit




berechnen: v (t  1)  Av (t ) . Das Verhältnis zwischen v (t  1) und v (t ) ist der
gesuchte Eigenwert  . Je mehr Iterationen man vor der Berechnung ausführt, umso
genauer lässt sich  berechnen.
Bsp.: Gegeben sind die beiden Muster

i  (1, 1,1, 1,1,1, 1, 1)
1

i 2  (1,1, 1, 1, 1,1, 1,1)
Wie die vorstehenden Beispiele zeigen, führt ein 2maliges Trainieren dieser beiden
Eingabemuster55 auf die folgende Matrix der Gewichte:
0.5
0
0
-0.5
0
0.5
-0.5
0
0
0.5
-0.5
..........
0
-0.5
0.5
........
-0.5
0
0
..........
0
0.5
0.5
........
0.5
0
0
.........
-0.5
0
0
..........
0
0.5
-0.5
.........
Jede der trainierten Muster ist ein Eigenvektor der Gewichtsmatrix mit Eigenwert 2.0
(, da jedes Muster während er Lernphase zweimal präsentiert wurde).
Die Testphase zeigt für 8 Zyklen:
1. Zyklus
Die Aktivierung steht auf 0.1exteingabe. Im ersten Zyklus führt die externe Einheit zur
Aktivierung jeder Einheit auf estr oder 0.1 mal der externenen Eingabe.
2. Zyklus
Berücksichtigt wird: (2  0.1  0.1)  exteingabe  0.3  exteingabe
Da das resultierende Aktivierungsmuster gerade 0.1 mal dem präsentierten Muster
ist, ist das Aktivierungsmuster ein Eigenvektor und so ist im 2. Zyklus das interne
Muster zwei mal so groß wie die vorhergehende Aktivierung (oder 0.2 mal der
externen Eingabe).
55
vgl. 2.5.2, 2.3.1
119
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3. Zyklus
Berücksichtigt wird: (2  0.3  0.1)  exteingabe  0.7  exteingabe
4.Zyklus
Berücksichtigt wird: (2  0.7  0.1)  exteingabe  1.5  exteingabe
Die Aktivierung überschreitet die Grenzen der Box ( 1.4  exteingabe ). Das Modell
schneidet auf 1.0 bzw. -1.0 ab.
Auch die nächsten Zyklen generieren größeren Input und werden abgeschnitten.
Interne Eingabe und Aktivierung verändern sich nicht mehr. Das Modell hat die
Grenzen der Box erreicht.
1. Vervollständigung von Mustern (pattern completion process)
Ein unvollständiger Testvektor enthält anstatt +1 bzw. -1 Nullen.
Liegt bspw. folgendes Testmuster vor:

i t  (1, 1,1, 1, 0, 0, 0, 0)
, dann ist die Aktivierung nach dem 1. Zyklus: ( 0.1, 0.1, 0.1, 0.1, 0, 0, 0, 0)
Das Skalarprodukt zu den in 2 Lernschritten erlernten Eingabemustern:

i  (1, 1,1, 1,1,1, 1, 1)
1

i 2  (1,1, 1, 1, 1,1, 1,1)
ist 0.5 bzw. 0. Die interne Eingabe des 2.Zyklus ergibt für das normalisierte
Skalarprodukt den Wert 0.15 mit Muster i1 und 0 mit Muster i2 . Die interne Eingabe


des 2. Zyklus ist dann: 2  0.1 0.5  i 1  0.1 i 1 . Diese interne Eingabe wird zur externen
Eingabe hinzuaddiert und führt zur folgenden Aktivierung:
( 0. 3, 0. 3, 0. 3, 0. 3, 0. 3, 0. 3, 0. 3, 0. 3) .


Die interne Eingabe im 3. Zyklus ist dann: 2  0.1 1. 5  i 1  0. 3  i 1 und führt zur
folgenden Aktivierung: ( 0. 4, 0. 4, 0. 4, 0. 4, 0. 3, 0. 3, 0. 3, 0. 3)

An dieser Stelle ist offensichtlich, daß die Aktivierung sich in Richtung i 1 bewegt.
Sobald die Grenzen +1 bzw. -1 erreicht sind, erhalt man eine exakte Reproduktion

von i 1 .
2. Gestörte Muster
Auch Störungen können u.U. erkannt werden. Wird bspw. ein Test mit dem Muster

i t  (1, 1,1, 1,1,1, 1,1)
an den (in 2 Lernschritten) trainierten Eingabemustern


i 1  (1, 1,1, 1,1,1, 1, 1) bzw. i 2  (1,1, 1, 1, 1,1, 1,1)
durchgeführt, dann ergibt sich:
Am Ende des 1. Zyklus: ( 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1)




Interne Eingabe für den 2. Zyklus: 0. 75  0.1 2 i 1  0. 25  0.1 2  i 2  0.15  i 1  0. 05  i 2
Aktivierung nach dem 2. Zyklus
(0.15 -0.15 0.15 -0.15 0.15 0.15 -0.15 -0.15)
(0.05 0.05 -0.05 -0.05 -0.05 0.05 -0.05 0.05)
120
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
----------------------------------------------(0.2 -0.1
0.1 -0.2
0.1 0.2 -0.2 -0.1)
Hinzu kommt die externe Eingabe
(0.1 -0.1
0.1 -0.1
0.1 0.1 -0.1
0.1)
---------------------------------------------(0.3 -0.2
0.2 -0.3
0.2 0.3 -0.3
0)
Interne Eingabe für den 3. Zyklus:




(0. 75  0.1  2  0. 75  01) i 1  ( 0. 25  0.1  0. 25  0.1 2) i 2  0. 225  i 1  0. 075  i 2
Aktivierung nach den 3. Zyklus
(0.225 -0.225 0.225 -0.225 0.225 0.225 -0.225 -0.225)
(0.075 0.075 -0.075 -0.075 -0.075 0.075 -0.075 0.075)
----------------------------------------------(0.3
-0.15
0.15 -0.3
0.15 0.3
-0.3
-0.15)
Hinzu kommt die externe Eingabe
(0.1
-0.1
0.1
-0.1
0.1
0.1
-0.1
0.1)
----------------------------------------------------(0.4
-0.25
0.25 -0.4
0.25 0.4
-0.4
-0.05)
Interne Eingabe für den 4. Zyklus:




(0. 75  0.1  0. 225) i 1  (0. 25  0.1  0. 075) i 2  0. 3  i 1  0.1 i 2



i 1 geht dreimal stärker in die interne Eingabe ein als i 2 . Der Einfluß von i 1 nimmt
zu, bis schließlich die Grenzwerte erreicht werden.
2.5.2 Hopfield-Netze
vgl. 2.6.1
121
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.5.3 Partiell rekrurrente Netze
In partiell rekurrenten Netzen werden häufig spezielle Rückkopplungsneuronen
(Kontextzellen eingesetzt). Dies hat den Vorteil, dass die Feedforward-Struktur des
Netzes weiterhin mit „klassischen“ Lernverfahren trainiert werden kann und nur die
Kontextzellen besonders behandelt werden müssen.
2.5.3.1 Jordan-Netze
Ausgangspunkt ist ein einfaches Feedforward-Netz, das um Kontextzellen erweitert
wurde, die die jeweilige Netzausgabe als Eingabe erhalten.
Eingabeschicht

Verborgene Schicht
KontextZellen mit
direkten
Rückkopplungen der
Stärke 

Ausgabeschicht
Abb. 2.5-2: Architektur eines Jordan-Netzes
- Die vorstehende Abb. zeigt ein dreischichtiges Netz
- Die Eingabeschicht besteht aus Eingabeneuronen (mit dem aktuell anliegenden
Eingabevektor) und den Kontextzellen. Die Kontextzellen können noch einmal mit
sich selbst rückgekoppelt (direkte Rückkopplung) sein.
- Anstelle von einer verdeckten Schicht können auch mehrere verwendet werden.
- Anzahl der Kontextzellen stimmen mit der Anzahl der Neuronen in der
Ausgabeschicht überein.
- Modifiziert durch das Lernverfahren werden nur die Feedforward-Verbindungen,
nicht die Rückkopplungen
Geht man davon aus, dass die Gewichte nicht mehr verändert werden, dann kann
der aktuelle Zustand des Netzes zum Zeitpunkt t beschrieben werden durch
t 1
S (t )  t 1 S 0    n 1o(t  n)
n 1
S (t ) : Aktueller Zustand des Netzes zum Zeitpunkt t
o(t )  f ( S (t ), I ()) : Ausgabe des Netzes zum Zeitpunkt „t“. Die Gesamtausgabe des
Netzes zu ein em Zeitpunkt „t“ hängt somit von S (t ) und der aktuellen Eingabe ab.
 und  : die in der vorstehenden Abbildung aufgeführten Parameter
122
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Unterstellt man, dass der Initialkontext der Nullvektor ist, vereinfacht sich die Formel
für S (t ) zu
t 1
S (t )   n 1o(t  n)
n 1
In diesem Fall ist S (t ) die exponentiell gewichtete Summe aller bisherigen
Ausgaben.
Der Wert von  steuert den Einfluß der bisherigen Eingaben, d.h.  steuert das
Errinnerungsvermögen des Netzes und liegt im Bereich von 0 bis 1. Kleine Werte
bewirken, dass weiter zurückliegende Eingaben nur noch minimalen Einfluß
besitzen. Bei Werte nahe bei 1 ist der Einfluß der Historie größer. In praktischen
Anwendungen hat sich ein Wert nahe um 0.5 bewährt.
2.5.3.2 Elman-Netze
In Elman-Netzen56 erhalten die Kontextzellen ihre Rückkopplung nicht von der
Ausgabeschicht, sondern von der verdeckten Schicht. Da die Gewichte an den
Verbindungen den Wert 1 besitzen, ergibt sich der neue Zustand der Kontextzellen
als Kopie der Ausgabe der verdeckten Zellen. Eine direkte Rückkopplung bei den
Kontextzellen existiert normalerweise nicht, sie kann aber eingeführt werden. Die
Anzahl der Kontextzellen muß hier also mit der Anzahl der verdeckten Schicht
übereinstimmen.
Eingabeschicht
Verborgene Schicht
Ausgabeschicht
Abb. 2.5-3: Architektur von Elman-Netzen
Da die Kontextzellen stets die Ausgabe der verdeckten Zellen enthalten und deren
Ausgabe von der vorherigen Eingabe und dem vorherigen Inhalt der Kontextzellen
abhängt, ist ein zeitlicher Bezug zu den früheren Eingabemustern hergestellt.
Für komplexe Anwendungen kann die Verwendung von mehreren Schichten sinnvoll
sein. Das führt zu hierarchischen Elman-Netzen.
56
J.L. Elman führte 1990 eine Modifikation der Jordan-Netze ein.
123
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Kontextzellen
Eingabeschicht
Verborgene Schicht
Verborgene Schicht
Ausgabeschicht
Abb. 2.5-4: Architektur von hierarchischen Elman-Netzen
Weitere Modifikation: Einführen einer über den Parameter  gesteuerten direkten
Rückkopplung. Für verschiedene Kontextschichten können unterschiedliche Werte
für  gewählt werden.
124
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6 Thermodynamische Modelle
2.6.1 Das Hopfield-Modell
2.6.1.1 Beschreibung
1. Übersicht
Der Physiker Hopfield beschäftigt sich mit dem Verhalten von Festkörpern
(Spingläsern). Das wird im wesentlichen bestimmt durch den "Ising-Spin", einer
Eigenschaft von magnetischen Atomen, die durch 2 Zustände (+1 oder -1)
beschreibbar ist. Die magnetische Wechselwirkung zwischen den Atomen läßt sich
durch einen mathematischen Formalismus beschreiben, der zu den Hopfield-Nezen
führt.
Hopfield-Netze gehören zur Klasse der Feedback-Netzwerke, d.h. die Ausgabe wird
wieder in das System als Eingabe zurückgeführt. Es sind autoassoziative Netze. Das
Hopfield-Netz besteht aus einer einzigen Schicht, in der N binäre Zellen vollständig
und symmetrisch miteinander vernetzt sind.
....
....
....
....
....
....
....
....
....
Abb. 2.6-1: Topologie des Hopfield-Netzes
Die vollständige Vernetzung zeigt deutlich ein stark dynamisches Verhalten. Eine
eindeutige Ausgabe liegt erst dann vor, falls ein Gleichgewichtszustand (vergleichbar
den thermischen Gleichgewicht des Spinglases) eingetreten ist, in dem der
Ausgangswert aller Einheiten im zeitlichen Verlauf konstant bleibt.
Die Eingabe erfolgt durch Setzen der Zustände der Zellen, der Eingabevektor ist die
Gesamtaktivität des Netzes zum Zeitpunkt t = 0.
125
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Ausgabe liegt dann vor, falls das Netz einen stabilen Zustand erreicht hat: der
Ausgabevektor ist die Aktivität des Netzes im stabilen Zustand.
Jedes Bit i eines Musters (jeder Pixel) wird dargestellt durch den Zustand a i einer
Zelle im Netz.
Die Hauptanwendung von Hopfield-Netzen liegt in der Mustererkennung. Gibt man
bspw. ein Schwarz-Weiß-Bild vor, so kann man jedes schwarze Pixel durch +1 und
jedes weiße Pixel durch -1 kennzeichnen.
2. Gewichte
Die Kopplung zwischen 2 Zellen "j" (Sender) und "i" Empfänger ist durch das
Gewicht wij gegeben.
wij  0 : verstärkende (exitatorische) Verknüpfung
wij  0 : schwächende (inhibitatorische) Verknüpfung
Zwei Einschränkungen sind nötig zur Übertragung der Erkenntnisse des SpinglasModells auf das Hopfield-Netzwerk:
(1) Die Gewichte sind symmetrisch: wij  w ji
(2) Es gibt keine Rückkopplung einer Zelle mit sich selbst: wii  0
2.6.1.2 Berechnungsgrundlagen
1. Dynamik
Sie wird beschrieben durch:
(1) die Propagierungsfunktion neti   wij  o j ( t )
j
 1, falls net i (t )   i  0

(2) die Aktivierungsfunktion57 ai (t  1)  ai (t ) , falls net i (t )   i  0
  1, falls net (t )    0
i
i

(3) die Ausgabefunktion oi (t )  ai (t )
Das kann zusammengefaßt werden zu
 1, falls net i (t )   i  0

oi (t  1)  oi (t ) , falls net i (t )   i  0
  1, falls net (t )    0
i
i

Die Wahl der Binärwerte ist im Hopfield-Netz nicht eindeutig. Man findet Versionen
mit den Werten 0 und 1 bzw. Modelle mit +1 und -1
57
unter der Voraussetzung, dass die Aktivierungsfunktion eines jeden Neurons die bipolare Treppenfunktion ist.
126
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Legt man die berechneten Werte ai bzw. oi wieder als Eingabe ans Netz, entstehen
weitere Netzwerte. Das wiederholt sich, bis möglicherweise das Verfahren
konvergiert, d.h. irgendwann ändern sich die Grenzwerte nicht mehr.




a  F (W  i  ) ,  : Schwellwertvektor

An das Netz wird also zu Beginn ein binäres Eingabemuster i aus den Zahlen +1
und - 1 gelegt: ai (0)  i1
Die weiteren Rechenschritte erfolgen nach der Iterationsvorschrift:
oi ( t )  F ( ai ( t ))
n
ai ( t  1)   wij  o j ( t )
j 1
Bsp.: Gegeben ist
1
-1
-1
Abb.: 2.6-2: Ein Hopfield-Netz mit drei Neuronen
0 1 1


W  1 0 1
1 1 0



"F" ist die Signumfunktion, alle Schwellwerte sind 0. Der Ausgabevektor bestimmt
 1

 
sich mit dem Eingabevektor i   1 in mehreren Schritten (2 Iterationen) zum
 
 1
Gleichgewichtszustand:
 1
 
1. Schritt: o  F(W i )   1 
 
 1

 
127
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
 1
 
2. Schritt: o  F(W i )   1
 
 1

 
1
 
3. Schritt: o  F (W  i )  1
1
 

 
Das Beispiel zeigt die synchrone Schaltdynamik eines Hopfield Netzes.
Die asynchrone Schaltdynamik eines solchen Netzes ist dagegen folgendermaßen
festgelegt: Es wird in zufälliger Weise eines der Neuronen i ausgewählt (z.B. so, daß
jedes Neuron dieselbe Wahrscheinlichkeit hat, ausgewählt zu werden).
Bsp.: Gegeben ist
1
1
Abb.: 2.6-3: Ein Hopfield-Netz mit zwei Neuronen
Die Schwellwerte sind 1  0 und 2  0
1. Entwicklung des Startzustands s0   1,1 bei synchroner Dynamik: s0   1,1 ,
s1   1,1 , s2   1,1 , etc. Das Netz schaltet fortwährend zwischen 2 Zuständen
hin und her. Es tritt niemals eine sog. stabiler Zustand ein.
2. Entwicklung des Startzustands s0   1,1 bei asynchroner Dynamik:
-
s1   1,1 . Dieser Zustand ist stabil.
Falls das linke Neuron ausgewählt wird, ergibt sich: s1  1,1 . Dieser Zustand ist stabil.
Falls das rechte Neuron ausgewählt wird, ergibt sich:
Ein stabiler Zustand eines rekurrenten Netzes ist ein Zustand mit folgenden
Eigenschaften:
- Für alle i mit net i (t )   i  0 ist oi (t )  yi (t )  1
- Für alle i mit net i (t )   i  0 ist oi (t )  yi (t )  1
Aktive Neuronen sind diejenigen, die den aktuellen Zustand ändern würden, wenn
sie ausgewählt werden. Ein stabiler Zustand y (t ) ist dadurch gekennzeichnet, daß
weder bei asynchroner noch bei synchroner Dynamik sich der Wert eines Neurons
ändert. In einem solchen Zustand gibt es keine aktiven Neuronen mehr.
Im vorstehenden Beispiel läuft das Netz bei allen, möglichen Startzuständen in einen
stabilen Zustand unter der Vorassetzung: „Die Auswahl der jeweils aktiven Neuronen
erfolgt fair“. „Fairness“ bedeutet: „Es darf nicht vorkommen, daß in einer
128
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Auswahlreihenfolge ein Neuron immer wieder übergangen wird, obwohl es in der
Lage wäre, den aktuellen Zustand zu verändern.
2. Energiefunktion
In der Spinglastheorie, aus der die Hopfield-Netze abgeleitet sind, sind
Gleichgewichtszustände dadurch charakterisiert, daß die Gesamtenergie (HamiltonFunktion) des Systems minimal wird.
E
1
  w ij  o j  o i  i  i  o i
2 i j
Falls die Schwellwerte auf Null gesetzt sind, ergibt sich
1
E     w ij  o j  o i
2 i j
Man kann für jeden Eingabevektor, der an das Netz angelegt werden kann, E
errechnen. Falls das für alle möglichen Eingabevektoren erfolgt, dann entsteht eine
Energielandschaft mit Maxima und Minima.
Bsp.: Gegeben ist das folgende Hopfield-Netz:
-2
1
2
1
4
5
-4
4
1
3
4
-3
Abb. 2.6-4: Ein Hopfield Netz mit 4 Neuronen
Alle Schwellenwerte sind gleich 0. Die folgenden Tabellen zeigen den Wert der
Energiefunktion für die 16 möglichen Zustände und die Ausgaben mit farblicher
Markierung der aktiven Neuronen.
Zustände
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
Energie
-1
Ausgabe
-4
2
6
-6
11
6
10
0
-6
-13
-2
-6
6
-12
11
8
2
0
-12
-5
-8
2
-2
2
-9
2
10
-8
2
-1
-6
-6
-2
-4
3
4
2
-8
-4
9
-4
-2
8
4
-1
6
6
2
4
-9
-2
-10
8
-2
-5
8
-2
2
-2
129
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
(1,1,1,1)
11
-8
-2
0
12
-13
2
6
-6
12
11
-6
-10
0
6
-1
4
-2
-6
6
Bei jeder Zustandsänderung verkleinert sich die Energie. Nach wenigen
Schaltschritten muß einer der beiden stabilen Zustände erreicht werden.
Die stabilen Zustände eines rekurrenten Netzes sind genau die lokalen Minima der
Energiefunktion des Netzes.
Hopfield forderte: Jedem gelernten Muster soll ein Energieminimum entsprechen.
Die Muster eines Hopfield-Netzes sind Minima der Energiefunktion58.
3. Bestimmen der Gewichte
Ist ein Muster gegeben, das in einem Hopfield-Netz gespeichert werden soll, dann
können die Gewichte des gesuchten Netzes analytisch (ohne Lernvorgang)
angegeben werden. Es gilt:
 0, falls i  j
wij  
ai  a j , falls i  j

Beweis: F (W  a )  F (  wij  a j )  F (  ai  a j  a j )  F ((  a 2 j )  ai )  ai
j
j
j
Bsp.: Minibild mit 4 Pixeln
*
*
1
 
   1
Der zugehörige Vektor (Muster) ist: a   
1
 
1
 
Das mit diesem Muster stationäre Hopfield-Netz besteht aus 4 Elementen, die
zugehörige Gewichtsmatrix ist:
 0 1 1 1 


  1 0 1  1
1 1
0  1


 1 1 1 0 



 
Man kann leicht nachprüfen, daß a  F (W  a ) ist.
58
Die Energiefunktion wird auch Hammilton-Funktion genannt
130
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.1.3 Mustererkennung mit Hopfield-Netzen
1. Aufbau der Gewichtsmatrix
Im praktischen Anwendungsfall sind mehrere Muster vorgegeben, die gespeichert
und umgeordnet werden müssen. Zu jedem vorgegebenen Muster gehört eine Matrix
W p mit den Gewichten
wij p  ai p  a j p
Aus derartigen Matrizen wird W = (W1+W2+...+Wp) gebildet.
Hat man nur wenige Bilder, dann speichert die Matrix W die Bilder (, falls sie nicht zu
stark korrelieren). Gibt es viele Bilder, reicht die Speicherkapazität nicht aus. Die
Wahrscheinlichkeit, daß ein Bild bei der Eingabe reproduziert wird, sinkt mit
ansteigender Anzahl Muster.
2. Kapazität
Für die Kapazität eines Hopfield-Netzwerks existieren Abschätzungen:
- Für Netze mit einigen hundert Neuronen schätzte Hopfield Mmax  0.15 N 59
1
N
2
- Für Netze mit sehr großem N gilt: M max 
log N
- Schließlich wurde gezeigt, daß Mmax  N ist
Interessant sind auch Hopfields Beobachtungen bzgl. des Netzverhaltens je nach
Speicherauslastung:
- Für M  0.15  N können nicht allzu ähnliche Muster unterschieden werden
- Für M  0.15  N bilden sich immer mehr Nebenminma, in denen das Netz während des Abrufs
hängenbleibt
- Für M  0. 5  N degenerieren die Energiebarrieren zwischen den einzelnen Minima, wodurch das
Netz die Assoziationsfähigkeit verliert.
Mit M  0.15  N bewegt man sich damit auf der sicheren Seite. Bei Hopfield-Netzen
ist im Vergleich zur konventionellen Speicherung der Speicherbedarf sehr hoch. Die
Muster werden ja in den Gewichten des Netzwerks gespeichert.
3. Aufgabe: Mustererkennung von 2 vorgegebenen Mustern
Gegeben sind 2 Muster:
59
Mmax: maximale Anzahl speicherbarer Muster, N: Anzahl der Neuronen
131
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Wie lautet die Gewichtsmatrix, falls diese Muster auf sich selbst abgebildet werden,
und ein schwarzer Punkt für ein Ausgangssignal von +1, ein weißer Punkt für -1
steht?
0

0
2

0
 2

0
2

0

2
0 2
0 0
0 0
2 0
0 2
2 0
0 2
2 0
0 2
0
2
0
0
0
2
0
2
0
2
0
2
0
0
0
2
0
2
0 2
2 0
0 2
2 0
0 2
0 0
0 0
2 0
0 2
0 2

2 0
0 2

2 0
0 2

2 0
0 2

0 0

0 0
Gib die Anzahl der Iterationsschritte an, nach denen sich die beiden Muster auf sich
selbst abgebildet haben?
Die beiden Muster werden schon nach einem Iterationsschritt auf sich selbst
abgebildet.
4. Gestörte Muster
Bei Mustererkennungsaufgaben ist es erforderlich, gestörte oder verrauschte Muster
den ungestörten Originalen zuzuordnen und damit die Auswirkungen der Störungen
zu eliminieren. Das kann ein Hopfield-Netz auch leisten. So können bspw. die beiden
folgenden Muster als ein gestörtes Kreuz bzw. Quadrat der vorstehenden Aufgabe
interpretiert werden.
1. gestörtes Muster (Quadrat)
2. gestörtes Muster (Kreuz)
132
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Nach den dargestellten Zwischenergebnissen der Iterationsschritte gibt das HopfieldNetz das jeweils ungestörte Muster aus.
Leider gibt es aber auch Fälle, bei denen das Hopfield-Netz nicht konvergiert. Das
folgende Muster weicht so stark von den bekannten Mustern (Quadrat, Kreuz der
vorstehenden Aufgabe), daß die Iteration nicht zum Stillstand kommt, sondern das
Hopfield-Netz ständig zwischen 2 Zuständen hin und her pendelt.
Weiterhin kann auch der Fall vorkommen, daß das Netz gegen einen Zustand
konvergiert, der keinem vorgegebenen Muster entspricht.
2.6.1.4 Anwendungen zur Mustererkennung
2.6.1.4.1 Applet zur Mustererkennung mit dem Hopfield-Netz
1. Aufgabenstellung
Zu einem aus 49 Bildpunkten bestehenden frei wählbaren Muster sollen weitere
Zufallsmuster erzeugt und in die Gewichtsmatrix aufgenommen werden. Nach dem
Lernen kann bzw. soll überprüft werden, ob das eingegebene Muster wiedererkannt
werden kann.
2. Anleitung zur Bedienung des Applet
1. Im Applet-Fenster werden in der Mitte zwei Eingabetabellen für zu erlernende
Muster angegeben. Durch Mausklicks können in die beiden Vorlagen jeweils bis zu
49 Bildpunkte angegeben werden. Defaultmäßig sind neun Bildpunke vorgegeben.
Durch Druck auf den Button "aendern" erscheint ein Fenster mit dem Titel
"Properties aendern".
2. Nach Drücken des Buttons "Lernen" erscheint in einem speziellen Fenster die
Gewichtsmatrix.
3. Zur Mustererkennung dient die im Applet-Fenster links oben angegebene Tabelle.
Das wiederzuerkennende Muster ist dort einzutragen.
4. Nachdem das wiederzuerkennende Muster dort eingetragen ist, erfolgt nach
Drücken des Buttons "auswerten", die Wiedererkennung durch ein spezielles
Fenster „Muster erkannt“. Wird das Muster nicht wiedererkannt, dann wird in einem
speziellen Fenster angezeigt: „Die Anzahl der Schritte bis zum Erreichen des
Gleichgewichtszustands und das Muster, das sich im ausgeglichenen Zustand
ergeben hat.
133
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
5. Ein wiederzuerkennendes Muster kann durch Drücken des Buttons „stoeren (um
1)" um einen Bildpunkt verändert werden.
6. Mit dem Button "fuellen" kann das Feld für wiederzuerkennende Muster
vollständig mit schwarzen Bildpunkten gefüllt werden.
3. Das Applet
http://fbim.fh-regensburg.de/~saj39122/doku/index.html
2.6.1.4.2 Bildmustererkennung mit Hilfe des Hopfield-Netzes60
http://fbim.fh-regensburg.de/~saj39122/wwr/Faces.html
60
http://fbim.fh-regensburg.de/~saj39122/wwr/Faces.html
134
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.1.5 Optimierungsaufgabe: Lösung des TSP mit Hopfield-Netzen
1. Problembeschreibung
1985 entdeckten J.J. Hopfield und D.W. Tank, daß Hopfield-Netze geeignet sind,
Lösungen von Optimierungsaufgaben bereitzustellen. Am häufigsten wurden
Lösungen zum TSP (Travelling-Salesman-Problem) mit Hopfield-Netzen versucht.
Bekanntlich muß in diesem Problem ein Handlungsreisender (Travelling Salesman)
nacheinander eine Reihe von Städten aufsuchen. Zur schnellen Durchführung seiner
Rundreise muß er eine optimale Rundreise auswählen, bei der er, beginnend in
einer Stadt, vor der Rückkehr alle anderen Städten genau einmal besucht, so daß
die Summe über die zwischen den Städten liegenden Strecke möglich klein ist. Die
Entfernungen zwischen den einzelnen Städten sind dem Handlungsreisenden
bekannt. Muß er insgesamt N Städte bereisen, gibt es offenbar N! mögliche
Rundreisen. Ist die Zahl N der Städte groß, so gibt es keine brauchbaren
Lösungswege, da meistens eine „kombinatorische Explosion“ auftritt. Aus der
Informatik ist bekannt, daß das TSP-Problem zur Klasse der NP-vollständigen
Probleme gehört. NP vollständig bedeutet: Es gibt keinen deterministischen
Algorithmus, der bei einer Eingabe der Länge n die Lösung mit einem Zeitbedarf p(n)
lösen kann, wobei p(n) ein Polynom ist. Allerdings kann dieses Problem ein nicht
deterministischer Algorithmus, der die Lösung „raten“ kann und dann die Lösung
verifiziert, in polynomialer Zeit lösen.
Mit Hopfield-Netzen läßt sich das Optimum nicht exakt bestimmen, aber gute
Näherungslösungen finden. Minimale Werte der Energiefunktion (lokale Minima) sind
beim Hopfield-Netz entscheidend für den Lösungsweg. Aus das TSP-Problem
übertragen, heißt das: Die Energiefunktion wird genau dann minimal, wenn die
optimierende Größe (Reiseroute, abzufahrende Strecke zwischen den Städten)
minimal wird. Sind N Städte aufzusuchen, dann fällt die Wahl auf ein Hopfield-Netz
mit N*N Neuronen, die in einem quadratischen Schema angeordnet sind:
0
1
0
0
0
0
0
0
1
0
1
0
0
0
0
0
0
0
0
1
0
0
1
0
0
Abb. 2.6-5: Neuronenbelegung beim TSP-Problem
Eine „1“ in einer Matrixposition (x,i) bedeutet: Die Stadt x wird als „i“-te Stadt
besucht. In jeder Spalte und in jeder Zeile steht genau ein Neuron auf „1“, alle
anderen sind „0“.
Eine zulässige Reiseroute ist immer dann bestimmt, wenn jede Zeile und Spalte
genau ein aktives Neuron besitzt. Die so besetzte Höhe garantiert, daß jede Stadt
genau einmal angefahren wird. Die Spalte mit genau einer „1“ bestimmt, daß der
Handlungsreisende zu einem Zeitpunkt immer nur eine Stadt besucht.
Gesucht werden dann Gewichte für das Netz. Da die Gewichte in die
Energiefunktion eingehen, wird dafür eine spezielle Energiefunktion mit folgenden
Randbedingungen ermittelt:
135
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
- Der Wert der Energiefunktion muß für Lösungen mit kürzerer Tourenlänge geringer
sein als für solche mit längerer Tourenstreckenlänge.
- Der Wert der Energiefunktion darf nur minimal sein für Lösungen, die genau in
jeder Zeile und Spalte eine „1“ besitzen
Mit diesen Randbedingungen erfolgt die Definition der einzelnen Terme zur
speziellen Energiefunktion:
(1) Jede Stadt darf nur einmal besucht werden. Benötigt wird daher ein Term, der
nur dann Null ist, wenn jede Zeile eine einzige „1“ besitzt. Dieser Bedingung genügt
der folgende Term, da das Produkt der beiden Werte y(x,i) und y(x,j) nur dann 1
ergibt, wenn die beiden Faktoren den Wert 1 besitzen und i ungleich j ist.
 y
x
i
j i
xi
 y xj
(2) Anderseits darf auch jede Spalte nur eine „1“ besitzen, da nicht mehrere Städte
gleichzeitig besucht werden dürfen. In Analogie zu (1) genügt dieser Bedingung der
Term
 y
x
i
v x
vi
 y xi
(3) Insgesamt müssen in der Matrix genau n „Einsen“ auftreten, d.h. jede Stadt und
jede Position muß einmal auftreten, denn durch (1) bzw. (2) ist nicht
ausgeschlossen, daß eine Zeile und Spalte nur aus Nullen besteht.



  y xi   .n 

 x i

2
(4) Die Länge der Tour soll insgesamt minimal sein. Als Distanz für eine Stadt x, die
an Position i steht, wird die Entfernung zu der Nachfolgestadt v an Position „i+1“,
addiert um die Entfernung zur Vorgängerstadt v an Position „i–1“, angenommen.
Dieser Bedingung genügt der Term:
 dist ( x, v)  y  y
xi
x
i
v ,i 1
 y v,i 1 
v
Bei dem Term unter (4) muß beachtet werden, daß jede Verbindung doppelt
berechnet wird. Deshalb muß ein Faktor 0.5 noch eingeführt werden, der auch als
allgemeine Energiefunktion auftritt. Die spezielle Energiefunktion enthält zusätzlich
noch Korrekturkomponenten für jeden der unter (1) bis (4) angegebenen Terme:
E
A
B
  y xi  y xj    y vi  y xi 
2 x i j i
2 x i v x
2
C 
D
 
   y xi   n     dist ( x, v)  y xi   y vi 1  y vi 1 
2  x i
2 x i v
 
Für diese Energiefunktion müssen die Gewichte wxi,vj durch Koeffizientenvergleich
mit der allgemeinen Energiefunktion für Hopfield-Netze bestimmt werden.
136
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Hierzu wird jedes Gewicht wxi ,vj in die 4 Komponenten A, B, C, D der speziellen
Energiefunktion zerlegt:
wxi ,vj  wxi( A,vj)  wxi( B,vj)  wxi(C,vj)  wxi( D,vj)
Unter Berücksichtigung der doppelten Indizes für die Neuronen latet die allgemeine
Energiefunktion:
E
1
  wxi ,vj  y xi  y vj   xi y xi
2 x v i j
x
i
Zur Bestimmung der Gewichte sind folgenden Fälle zu berücksichtigen:
1. x = v und j <> i
In diesem Fall ist lediglich der erste Term aus der speziellen Energiefunktion zu
berücksichtigen:
1
falls i = j
( A)
wxi ,vj   A   xy  (1   ij ) mit  ij  
0
sonst.
2. x <> v und j = i
Nur der zweite Term ist von Null verschieden. Man erhält wxi( B,vj)   A   ij  (1   xy )
3. Im Fall aller anderen Terme einer unzulässigen Tour soll gelten: wxi(C,vi)  C
4. Für den Fall x <> v, j = j + 1 und j = j – 1 gilt der 4. Term der speziellen
Energiefunktion. Man erhält wxi( D,vj)  D  dist xv  ( j ,i 1   j ,i 1 )
Zusammengefasst führt das zur folgenden Formel für die Berechnung der Gewichte:
wxi ,vj   A   xy  (1   ij )  B   ij (1   xy )  C  D  dist xy  ( j ,i 1   j ,i 1 )
Problematisch ist das Schätzen der konstanten A bis D. Wählt man A, B, C groß im
Verhältnis zu D, so konvergiert das Hopfield-Netz fast immer zu gültigen Touren, die
weit entfernt vom Optimum liegen. Wählt man A, B, C zu klein, so führt das zu
ungültigen Routen.
2. Das Applet zur Lösung des TSP-Problems mit einem Hopfield-Netz
http://fbim.fh-regensburg.de/~saj39122/doerei/TSP.html
137
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.1.6 Lösung des N-Damen-Problems
1. Das 4- bzw. 8- bzw. N-Damenproblem
Betrachtet man die Verteilung der Neuronen im Hopfield-Netz zur Lösung des TSPProblems, kann man die Schlußfolgerung ziehen, auch ähnlich geartete Probleme,
die keine Optimierungsprobleme sind, z.B. das 8-Damen-Problem, mit einem
Hopfield-Netz zu lösen. Das 8-Damen-Problem wird in der Informatik, ebenso wie
das TSP-Problem, häufig mit Hilfe eines Backtracking-Algorithmus gelöst. Ziel des 8Damen-Problems ist es, auf einem Schachbrett acht Damen so zu plazieren, daß
keine Dame eine andere schlagen kann.
Abb. 2.6-6: Eine Lösung des 8-Damen-Problems
Die Lösung des Problems wird beschrieben am einfachen, übersichtlich
darstellbaren 4-Damen-Problem, einer Vereinfachung des alllgemein bekannten 8Damen-Problems. Hier sollen bekanntlich 8 Damen so auf einem Schachbrett
postiert werden, daß sie sich nicht schlagen können, d.h.: 2 Damen stehen nie in
derselben Zeile oder Spalte oder Diagonale.
Auf eine Lösung dieses Problems führt die folgende Baumstruktur:
138
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
(_,_,_,_)
1
2
3
2
(2,_,_,_)
(1,_,_,_)
4
1
S
S
(1,3,_,_)
2
3
S
(1,4,_,_)
4
2
3
4
4
(2,4,_,_)
1
S
S
(2,4,1,_)
(1,4,2,_)
(2,4,1,3)
Abb. 2.6-7: Zur Lösung des 4-Damen-Problems
Die Lösung des Problems läßt sich anschaulich darstellen:
0
-3
3
y
x
x
x
x
x
2
8
5
139
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Da Damen sich auch in der Diagonale bedrohen, sind auch Haupt- und
Nebendiagonalenplätze zu überwachen.
Das 4- bzw. 8-Damen-Problem kann zum N-Damen-Problem verallgemeinert
werden, bei dem „N“ Damen auf einem Spielfeld mit N*N Feldern so angeordnet
werden sollen, daß in jeder Zeile, Spalte und Diagonale maximal eine Dame
vorhanden ist.
Das N-Damen-Problem gehört zu einer Klasse von Problemen, für die höchstwahrscheinlich kein deterministischer Algorithmus existiert. Das bedeutet: Solche
Probleme sind theoretisch lösbar, da ein Lösungsalgorithmus angegeben werden
kann (z.B. Backtracking). Die Rechenzeit wächst aber stark an, daß durch
deterministische Verfahren keine Lösung gefunden werden kann.
2. Versuch zur Lösung des N-Damen-Problems
Ansatz: Neuronen werden ähnlich, wie beim TSP, zu einer dem Schachbrett
entsprechenden Matrix angeordnet (Identifilation durch Zeilenindex i und durch
Spaltenindex j). Ein aktives Neuron (oij = 1) bestimmt: „Auf Zeile i und Spalte j
befindet sich eine Dame“. Ein inaktives Neuron (oij = 0) legt fest: „Das Feld,
identifiziert durch Zeile i und Spalte j ist leer“.
Zwischen allen Neuronen einer Zeile, einer Spalte und den Diagonalen müssen
negativ eingerichtete Verbindungen eingerichtet werden.
Abb. 2.6-7: Hopfield-Netzwerk in einem 4 Damen Problem zum 2. Neuron der 1.Zeile
3. Knotendynamik (eines Hopfield-Netzes zur Lösung des N-Damen-Problems):
(1) netij   wij,mn  omn  
m,n
140
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
1, falls net ij  0
(2) oij  
0, sonst

  , falls (d ij , d mn )  ( X i , X m

wij,mn     , falls i  m und j  n 61

0, sonst .

positives  : konstante Anregung. Bewirkt, daß das Neuron autom. aktiv ist, sofern
keine negativen Gewichten eingehen.
wij,mn: Gewicht der Verbindung zwischen dem Neuron in Zeile i und Spalte j und dem
Neuron in Zeile m und Spalte n.
  : Die mit   gewichteten Verbindungen sorgen dafür, daß sich 2 Neuronen einer
Spalte oder Diagonale gegenseitig hemmen, da gleichzeitige Aktivität eine
Randbedingung verletzt.
 : Die mit  gewichteten Verbindungen hemmen die Neuronen einer Zeile und
sorgen dafür, daß jede Variable nur maximal einen Wert annimmt.
Die Anwendung des Hopfield-Algorithmus auf eine derartiges Netzwerk führt in der
Regel zu keiner Lösung des N-Damen-Problems. Es sind weniger als N Neuronen in
der Regel aktiv. Solche nicht vollständige Lösungen entsprechen lokalen Minima der
Energiefunktion.
4. Applet: Lösung des N-Damen-Problems mit Hilfe eines Hopfield-Netzwerks
http://fbim.fh-regensburg.de/~saj39122/rofbrue/index.html
61
Gewicht der Verbindung zwischen dem Neuron in Zeile i und Spalte j und dem Neuron in Zeile m und Spalte
n
141
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.2 Das Guarded-Discrete-Stochastic-Netzwerk (GDS)
2.6.2.1 Beschreibung
Durch Einführung zusätzlicher Neuronen wird es einem Hopfield-Netz ermöglicht,
aus lokalen Energieminima zu entkommen und die Suche nach energetisch
günstigeren Zuständen fortzusetzen. "Guarded" steht für zusätzliche "GuardNeuronen"62, die jeweils eine bestimmte Anzahl von Hopfield-Neuronen überwachen.
"Discrete" gibt an, daß Neuronen nur binäre Zustände annehmen können und eine
diskrete Schwellwertfunktion als Aktivierungsfunktion verwendet wird. "Stochastic"
besagt, daß eine zufällige Absuche des Lösungsraums vorzusehen ist.
Das GDS-Netzwerk63 wird zur Lösung von Constraint-Satisfaction-Problemen
(CSP) eingesetzt. Hier sind bestimmte Zuordnungen unter Randbedingungen zu
realisieren, z.B.: Der Wunsch eines Dozenten an einem Tag in der Woche frei zu
haben, ist mit dem Stundenplan abzustimmen. Durch weitere Constraints wird der
Lösungsraum zusätzlich eingeschränkt. Innerhalb eines CSP soll die Problemlösung
unter Beachtung aller Constraints erzielt werden.
Ein CSP besteht damit aus einer Menge Variablen {X1, ... , Xn}. Jede Variable kann
bestimmte Werte dij annehmen, die durch den zugehörigen Wertebereich (Domain)
Di = {di1, ... , dim) explizit definiert werden. Zwischen 2 beliebigen Variablen X i und
Xk sind bestimmte paarweise Kombinationen von Variablenausprägungen verboten.
Das wird durch einen Constraint C(Xi,Xk) spezifiziert (Teilmenge des cartesischen
Produkts ). Falls bspw. (d13,d24) in C(X1,X2) enthalten ist, darf nicht gleichzeitig X1
den Wert d13 und X2 den Wert d24 annehmen.
2.6.2.2 Algorithmus zum "Damen-Problem" mit einem GDS-Netzwerk
1. Problemstellung (vgl. Lösung des N-Damen-Problems64)
Lösung mit NN: Die Knotendynmik des Hopfield-Netzes ist auch hier zunächst
maßgebend.
(1) netij   wij,mn  omn  
m,n
1, falls netij > 0
1, falls net ij  0
(2) oij  
0, sonst

  , falls (d ij , d mn )  ( X i , X m

wij,mn     , falls i  m und j  n 65

0, sonst .

62
Wächter
1990 von H.-M. Adorf und M. D. Johnston vorgestellt
64 vgl. Kruse, Hilger … : Programmierung Neuronaler Netze, Kapitel 7: Thermodynamische M odelle
65 Gewicht der Verbindung zwischen dem Neuron in Zeile i und Spalte j und dem Neuron in Zeile m und Spalte
n
63
142
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Dabei bedeutet die Bedingung der ersten Zeile nichts anderes als die Verletzung
eines Constraints bzgl. zweier Neuronen uij und umn verschiedener Zeilen (gleiche
Spalte oder Diagonale). Bei der Implementierung des N-Damen-Problemes kann auf
die explizite Angabe der Constraints C verzichtet werden, weil diese nur in gleichen
Spalten und Diagonalen sein können und damit einfach zu berechnen sind.
Die charakteristische Eigenschaft eines einfachen Hopfield-Netzes ist das
schrittweise Konvergieren auf ein lokales Minumum der Energiefunktion. Bei
Erreichen eines solchen Minimums sind zwar keine Randbedingungen verletzt, es
werden aber meistens nicht alle geforderten Zuordnungen erfüllt. Beim N-DamenProblem heisst das konkret, dass in einem lokalen Minimum weniger als N Damen
gesetzt sind und eine vollständige Lösung mit N Damen nur durch Zufall bei
entsprechend häufigen Lösungsversuchen gefunden werden kann.
Das Guarded-Discrete-Stochastic-Netzwerk kann als erweitertes Hopfield-Netz mit
sog. „Guard-“ (Wächter-) Neuronen angesehen werden, die jeweils eine bestimmte
Anzahl von Hopfield-Neuronen überwachen. "Discrete" bedeutet, dass die
Ausgabefunktion der Neuronen nur binäre Werte annehmen kann („1“ oder „0“ bzw.
„-1“), und „Stochastic“ deutet auf die zufällige Auswahl der Neuronen hin.
Das Guard-Neuron ist mit allen der ihm zugeordneten Zeile asymmetrisch
verbunden. Das Guard-Neuron ist nur dann aktiv, wenn in der entsprechenden Zeile
alle überwachten Neuronen uij inaktiv sind.
(3) net gi      oij   g
0  g  
0   g   ist eine konstante Anregung, die zur Aktivierung des Guard Neuron führt,
sofern von allen aktiven überwachten Neuronen keine mit   gewichteten
Verbindungen eingehen.Der Faktor  bezeichnet dabei die Stärke der negativen
Gewichte der überwachten Neuronen und der positive Bias  g sorgt für eine
konstante Anregung, damit das Guard-Neuron automatisch aktiv ist, falls von den
überwachten Neuronen keine negativen Gewichte eingehen.
Die Ausgabefunktion der Guard-Neuronen ergibt sich zu:
1, falls net gi  0
(4) o gi  
0, sonst

Umgekehrt regt ein aktives Guard-Neuron durch die stark positiv gewichteten
Verbindungen zu den überwachten Neuronen bisher inaktive Neuronen so stark an,
dass mindestens ein Neuron der zugehörigen Zeile aktiv wird.
(5) netij   wij  omn      ogi mit   0,   0
m,n
 muß alle möglichen negativen Einwirkungen auf das überwachte Neuron u ij
kompensieren.
143
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Das führt auf den folgenden (gegenüber dem Hopfield-Modell veränderten)
Algorithmus:
(a) Initialisiere alle normalen Hopfield-Neuronen mit oij = 0
und alle Guard-Neuronen mit ogi = 1
(b) Wähle ein Neuron zufällig aus
(c) Berechne die neueste Ausgabe oij gemäß (5) und (2)
(d) Berechne die neueste Ausgabe ogi des zugehörigen GuardNeurons gemäß (3) und (4)
(e) Wiederhole die Schrite (b) bis (d) solange, bis ein
Gleichgewichtszustand eingetreten ist.
2. Erweiterung der Energiefunktion:
Die Erweiterung der Energiefunktion
E  1 / 2   wij,mn  oij  om,n   o g .i
um die Summe der Ausgabewerte der Guard-Neuronen (2. Term) führt dazu, daß
Konfigurationen mit weniger als N Damen (und keiner Verletzung von Constraints)
nicht der minimalen Netzenergie entsprechen, und diese somit nur erreicht wird,
wenn eine zulässige Lösung mit N Damen gefunden wurde. Dies ist auch der
wesentliche Vorteil eines GDS-Netztes, nämlich aus lokalen Minima der
Energiefunktion entweichen zu können. Der Nachteil dabei ist jedoch, daß aufgrund
der asymmetrischen Verbindungen zwischen Guard- und Hopfield-Neuronen die
monotone Energieminimierung und die garantierte Konvergenz in ein lokales
Minimum der Energiefunktion verloren gehen, so daß man nach jedem
Lösungsversuch die Netzenergie berechnen muss. Dadurch kann es
vorkommen,daß innerhalb eines Lösungsversuches kein Energieminimum gefunden
wird, weshalb man ein Abbruchkriterium einführen muss, dass die Iterationen pro
Lösungsversuch abbricht und einen komplett neuen Lösungsversuch startet.
2.6.2.3. Das Applet zur Lösung des N-Damen-Problems mit einem GDSNetwerk
http://fbim.fh-regensburg.de/~saj39122/rofbrue/index.html
144
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.2.4. Erläuterungen zur Implementierung
Der prinzipielle Lösungsalgorithmus besteht aus einer äusseren und inneren
Schleife. In der äusseren Schleife wird pro Durchlauf eine zufällige Zeilensequenz
erzeugt und danach in der inneren Schleife abgearbeitet. In der jeweiligen Zeile wird
nun das zum aktuellen Netzwerkzustand inkompatibelste Neuron ermittelt.
Dabei handelt es sich um dasjenige Neuron, welches bei einem Zustand von o i = 1
den größten negativen bzw. bei oi = 0 den größten positiven Nettoinput neti aufweist.
Sind beide Fälle vorhanden, wird der mit dem betragsmäßig größeren Wert
verwendet. Haben mehrere Neuronen den gleichen Wert, wird eines zufällig ausgewählt, sein Zustand verändert und der neue Zustand des Netzes gemäß (3) und
(1) berechnet. Ist keiner der beiden Fälle vorhanden, findet in der Zeile keine
Veränderung statt. Dieses gezielte Vorgehen beschleunigt im Gegensatz zu einer
zufälligen Auswahl der Neuronen die Lösungssuche erheblich, da pro Durchgang
jede Zeile an die Reihe kommt und darin evtl. nur ein solche Veränderung eines
Neurons vorgenommen wird, die die Netzenergie nicht größer werden lässt.
Die äussere Schleife wird solange durchlaufen, bis in der inneren Schleife keine
Veränderungen von Neuronen mehr stattfinden (d. h. das Netz ist stabil) oder bis das
Abbruchkriterium erfüllt ist (je nach Problemgröße sind Werte von 2 bis 10
Durchläufen geeignet). Ist die Gesamtenergie des Netzes dann gleich dem
Minimum, so ist eine zulässige Lösung gefunden, ansonsten muss ein komplett
neuer Versuch gestartet werden.
Entsprechende Testreihen haben gezeigt, dass bei N = 8 eine Lösung meist nach
weniger als 5 Versuchen gefunden wird. Selbst bei einer Problemgröße von N = 50
sind meist nur zwischen 10 und 30 Versuche (manchmal auch weniger als 10,
selten mehr als 50) notwendig, und die Rechenzeit liegt dabei bei ca. 20 bis 40
Sekunden (Pentium II, 333MHz, 64MB). Bei Werten darüber wird aber die
vierdimensionale Gewichtsmatrix so groß (z. B. bei N = 60 knapp 13 Mio. Felder),
daß der nötige Arbeitsspeicher auf Festplatte ausgelagert wird und sich dadurch die
Berechnung extrem verlangsamt. Abhilfe könnte hier aber eine Implementierung der
Randbedingungen über eine direkte zyklische Verbindung der Neuronen einer Zeile,
Spalte und den Diagonalen schaffen, wodurch man auf die (vollständige) Vernetzung
über die Gewichtsmatrix verzichten könnte.
145
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.3 BAM
2.6.3.1 Beschreibung
Das BAM-Modell (bidirektionaler assoziativer Speicher) wurde Mitte der 80er Jahre
von B. Kosko66 entwickelt.
Das BAM-Netzwerk besteht aus 2 Schichten, der S1-Schicht (Eingabeschicht) und
der S2-Schicht (Ausgabeschicht). Die binären Elemente der Schichten können
Aktivitäten 1 und 0 annehmen. Die Transferfunktion der Elemente ist:
oi (t  1)  1, wenn  wij  o j ( t )  0
oi (t  1)  0, wenn  wij  o j ( t )  0
oi (t  1)  oi (t ) , wenn  wij  o j ( t )  0
Die beiden Schichten sind in beiden Richtungen vollständig miteinander verbunden.
Die Gewichte sind symmetrisch: wij  w ji
x1
j=1
x2
j=2
xn
..............
j=n
S1-Schicht
w ij  w
i= 1
i= 2
................
i= m
y1
y
................
y
b1
b2
................
bm
2
ji
S2-Schicht
m
Abb. 2.6-8: Das BAM-Netzwerk
Das BAM-Netzwerk hat eine große Ähnlichkeit mit dem Hopfield-Netzwerk. Ist die
Anzahl der Elemente der S1-Schicht und der S2-Schicht identisch und wählt man die
Gewichtsmatrix symmetrisch, so entspricht das BAM-Netzwerk exakt dem HopfieldNetzwerk, falls das Netzwerk autoassoziativ trainiert wird.
66
Bart Kosko: Constructing an Associative Memory, BYTE September 1987
146
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.3.2 Lernen

Das BAM-Netwerk lernt einen S1-Vektor x mit n Komponenten mit einem S2-Vektor

y mit m Komponenten zu assoziieren67.



W  x y T
Die m  n -Gewichtsmatrix wij des BAM-Netzwerks kann - wie beim Hopfield-Netz - in
einem einzigen Schritt berechnet werden. Werden die korrespondierenden


Vektorpaare k gelernt, so gilt für die Gewichtsmatrix: W   Wk .
Bsp.: Gegeben sind die Muster

T

T

T

T
a1  (1, 0,1, 0,1, 0) b1  (1,1, 0, 0)
a2  (1,1,1, 0, 0, 0) b2  (1, 0,1, 0)
Die beiden binären Assoziationen werden folgendermaßen von einem BAMNetzwerk erlernt:
 
1) 0-Komponenten der zu erlernenden Vektoren a , b werden während des
Lernvorgangs auf -1 gesetzt:

x1T  (1,1,1,1,1,1)

x2T  (1,1,1,1,1,1)

y1T  (1,1,1,1)

y 2T  (1,1,1,1)



2) Bestimme die Gewichtsmatrix W  x y T

T

x 1  y1

T

x 2  y2
 1
 1 1 1 1
 


 1
 1  1 1 1 
 1
 1 1 1 1
    1 1 1 1  

 1
 1  1 1 1 
 1
 1 1 1 1
 


 1
 1  1 1 1 
 1
 1 1 1 1
 


 1
 1 1 1 1
 1
 1 1 1 1
    1 1 1 1  

 1
 1 1 1 1 
 1
 1 1 1 1 
 


 1
 1 1 1 1 

67
Die 0-Komponenten der zu erlernenden Vektoren werden während des Lernvorgangs auf -1 gesetzt und mit

bzw.
y bezeichnet
147
x
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
0
0 2
2


0
 0 2 2
2

0
0 2
W

0
2
 2 0
0
2 2 0 


0
2
 2 0
2.6.3.3 Energiefunktion
Auch im BAM-Netzwerk kann eine Energiefunktion definiert werden:

T


E   b  (W  a ) .
T
Die Energie ist immer minimal, wenn die Aktivitäten der Elemente in beiden
 
Schichten einem gelernten Vektorpaar x , y entsprechen.
Bsp.: Für die beiden gelernten Muster errechnet sich die Energie folgendermaßen:
1. Muster
 1
 
0 2 2 0 2  0  4 
2


 
 
0 2 0
0 2
0   1  2 
T

W a 
  
0 2
0
0 2 0   0  2


 
0 2   1  4
 2 0 2 2
 
 0
 4
 
2
E  1 1 0 0     6
 2
 
 4
2. Muster
 1
 
0 2 2 0 2  1  4 
2


 
 
0 2 0
0 2
0   1  2
T

W a 
  
0 2
0
0 2 0   0  2 


 
0 2   0  4
 2 0 2 2
 
 0
148
 4
 
2
E  1 0 1 0     6
 2
 
 4
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.3.4 Abruf
Während der Abrufphase werden die Elemente der S1-Schicht mit einem Vektor

a ( t 0 ) besetzt. Danach läßt man das Netzwerk frei laufen. Die S2-Schicht berechnet

über die Summe der Ausgabe der S1-Elemente den Vektor b ( t  1) . Dieser Vektor ist

die neue Eingabe zur S1-Schicht und produziert einen neuen Vektor a ( t  1) usw. Bei
jedem Zyklus wird das Netzwerk die Energie E verkleinern, bis es sich im lokalen
Minimum von E befindet (stabiler Zustand).
Man kann zeigen, daß die Änderung der Aktivitäten der Elemente immer zu einer
Verringerung der Energie führt:
T


T 


T 

E( t  1)   b ( t  1) a ( t ) W  E( t )   b  a ( t )  W
und
T

E( t  1)   a ( t  1) b( t ) W  E( t )   a  b ( t )  W
Bsp.:
a) Abruf des 1. Musters
 1
 
0
2 2 0 2  0  4 
2


 
 
0 2 0
0
2
0   1  2 
T

W a 
 
0
2
0
0 2 0   0  2


 
0 2   1  4
 2 0  2 2
 
 0
Das führt zur gewünschten Ausgabe (1,1, 0, 0) T .
0
0 2
2
 2


 
0   1  2
 0 2 2
 
2
0
0 2  1  2 
 


0 2   0  2
 2 0
 
0
2 2 0   0  2 


 
0 2
 2 0
 2
Das führt zu der gewünschten Eingabe. (1, 0, 1, 0, 1, 0) T
b) Abruf des 2. Musters
149
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
 1
 
0 2 2 0 2  1  4 
2


 
 
0 2 0
0 2
0   1  2
T

W a 
  
0 2
0
0 2 0   0  2 


 
0 2   0  4
 2 0 2 2
 
 0
0
0 2
2
 2


 
0   1  2 
 0 2 2
 
2
0
0 2  0  2 
 


0 2   1  2
 2 0
 
0
2 2 0   0  2


 
0 2
 2 0
 2
Das führt zur gewünschten Eingabe (1, 1, 1, 0, 0, 0) T

T
c) BAM ist fehlerkorrigierend. So kann der Verktor a2  (1,1,1, 0, 0, 0) um 1 Bit gestört

sein: a T  ( 0,1,1, 0, 0, 0) . Beim Abruf ergibt sich:
 0
 
0 2 2 0 2  1  2 
2


 
 
0 2 0
0 2
0   1  2
T

W a 
  
0 2
0
0 2 0   0  2 


 
0 2   0  4
 2 0 2 2
 
 0
Das führt zu der gewünschten Ausgabe: (1,0,1,0)T. Die Energie beträgt -4 (anstatt 6).
d) Ein weiteres Muster kann in das BAM-Netzwerk aufgenommen werden:

T

T
a2  (1,1, 0, 0,1,1) bzw. b2  ( 0,1,1,1) . Die Gewichtsmatrix ist dann:
 1 1 1 1


 1 1 3 1 
 3 1 1 3

W

 1 1 1 1 
 1 3 1 1 


 3 1 1 3 
Abruf des 3. Musters:
150
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
 1
 
 1 1 3 1 1 3  1  4


 
 
1 1 1 1 3 1   0  4 
T

W a 
  
 1 3 1 1 1 1   0  4 


 
 1 1 3 1 1 3   1  4 
 
 1
bzw.
 1 1 1 1
 1


 
 1 1 3 1   0  3 
 3 1 1 3  1  5

     

1

1

1
1

  1  1
 1 3 1 1   1  3 


 
 3 1 1 3 
 5
 4
 

 
4
T
T
Die Energie ist: E   b  W  a  0 1 1 1     12
 4
 
 4
Diese Muster führt zu einem weiteren Minimum, das einen geringeren Wert zeigt wie
die lokalen Minima der vorangegangenen Muster.
2.6.3.5 Kapazität
Sie ist (ähnlich dem Hopfield-Netzwerk) begrenzt. Werden zu viele Muster
gespeichert, entstehen "falsche Minima" (spurios states). Das Netzwerk assoziiert
nicht mehr nur die gewünschten Vektoren, sondern auch nicht gelernte Muster. Man
1
N
2
kann für die Kapazität vom Hopfield-Netzwerk übertragen: M 
(mit N =
log N
Anzahl der Elemente der kleineren Schicht und M = Zahl der zu speichernden
Muster).
2.6.3.6 Applet: Mustererkennung mit BAM
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/dosch/BAM.html
151
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.4 Simulated Annealing
2.6.4.1 Beschreibung
Das Hopfield-Netz speichert Binärwörter, für die die Energiefunktion minimal ist. Das
errechnete Minimum ist lokal. Das Hopfield-Modell ist unbrauchbar, fall das globale
Minimum der Energiefunktion gefunden werden soll.
Zur Bestimmung des Minimums der Energiefunktion sind die Hopfield-Iterationen zu
erweitern. Der daraus resultierende Algorithmus zeigt eine Analogie zu einem
Simulationsverfahren, das "Simulated Annealing" (simuliertes Abkühlen) genannt
wird.
Das Iterationsverfahren, das der Berechnung in Hopfield-Netzen zugrundeliegt, wird
im wesentlichen durch 2 neue Berechnungsverfahren ergänzt:
1. Zufällige Auswahl einer Zelle i und Berechnung des neuen Zustands (Aktivität
bzw. Ausgabe) oi(t+1)
2. Der neue Zustand ist durch folgende Wahrscheinlichkeitsfunktion bestimmt:
p ( oi  1) 
1 e


1
( wij o j ( t )   i )/ T
p
Abb. 2.6-9: Wahrscheinlichkeitsfunktion
T > 0 ist ein beliebiger Parameter. In Analogie zur Simulation bei der Abkühlung von
Materie bezeichnet man T als "Temperatur". Je nach Größe von T ändert sich die
Wahrscheinlichkeit, daß für eine bestimmte Netzeinwirkung (Eingabe) der Zustand
oi= 1 angenommen wird:
T = 0: binäre Transferfunktion
T sehr groß: (p(oi=1)=1/2, d.h. die Neuronen werden unabhängig vom Ausgang der
Berechnung (neti(t)) mit der Wahrscheinlichkeit 1/2 auf 1 gesetzt. Das bedeutet:
Global können alle Zustände des Netzes angenommen werden. Das
Berechnungsverfahren bleibt nicht mehr in einem lokalen Minimum hängen.
Wählt man T nicht zu groß und nicht zu klein. dann wird mit einer
Wahrscheinlichkeit, die umso größer ist, je kleiner T ist, das Energieminimum
gesenkt. Gleichzeitig kann ein lokales Minimum verlassen werden, da wegen T > 0
152
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
alle Zustände angenommen werden können. Zweckmäßig beginnt man mit großem
T die Rechnung und läßt T langsam kleiner werden (d.h.: Der Parameter T wird im
Laufe der Zeit verändert).
2.6.4.2 Berechnung
1. Dynamik
Die Dynamik des Simulated Annealing ist bestimmt durch den folgenden
Simulationsprozeß:
(1) Wähle ein Neuron zufällig aus
(2) Errechne die Wahrscheinlichkeit
p ( oi  1) 
1 e


1
( wij o j ( t )   i )/ T
(3) Erzeuge eine gleichverteilte Zufallszahl z: 0 <= z <= 1
(4) Falls z <= p, dann setze oi = 1, sonst ist oi = 0
(5) Weiter bei (1)
Die Dynamik führt zu einem stabilen Zustand, falls T klein gewählt wird. Bei großem
T besteht immer die Wahrscheinlichkeit, daß die Gesamtenergie zunimmt und
danach ein lokales Minimum verlassen werden kann.
2. Energiefunktion
E
1
  wij  o j  oi  i i  oi
2 i j
heißt Energie zum Zustand ai (= Ausgangsgröße oi). Bezogen auf Neuron i beträgt
die Energie:
N
E    wij  o j  ai  i  ai
j
N
N
E
   wij  o j  i   (  wij  o j  i )
ai
j
j
N
E   (  wij  o j  i )  ai
j
Setzt man Neuron i von 0 auf 1, dann ist ai  1  0  1
Daraus folgt: p(oi  1) 
1
1  e E / T
153
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
p(oi=1)
E / T
Abb. 2.6-10: Verlauf von p(oi)=1
Für E  E1  E0  0 folgt p(oi=1)>1/2. E1 ist die Energie, wenn Neuron i den Zustand
1 hat und E0 ist die Energie, wenn Neuron i den Zustand 0 hat.
Allgemeingülig ist folgender Satz: Sind Z0 und Z1 zwei Zustände des Netzes mit den
zugehörigen Energien E0 und E1, dann gilt für die Wahrscheinlichkeit der Zustände:
p ( Z0 )
 e( E1  E0 )/ T
p( Z1 )
Daraus läßt sich folgern, daß das Verfahren des simulierten Kühlens stochastisch
gegen das absolute Minimum konvergiert. Hat bspw. die Energiefunktion folgenden
Verlauf
E
Z
Z1
Z0
Abb. 2.6-11: Energiekurve
154
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
p ( Z0 )
 e( E1  E0 )/ T  1 und p( Z0 )  p( Z1 ) , d.h.: Die Wahrscheinlichkeit für den
p( Z1 )
Zustand des absoluten Minimums ist größer als die Wahrscheinlichkeit für die
Zustände der relativen Minima.
Generell gilt: Das Verfahren des simulierten Kühlens konvergiert gegen den Zustand,
für den die Energie das absolute Minimum annimmt.
Hinweis: Da das simulierte Kühlen ein stochastisches Verfahren ist, erhält man das
Minimum zwar mit Wahrscheinlichkeit, aber nicht mit Sicherheit.
, dann ist
3. Boltzmann-Verteilung
Mit einer gewissen Wahrscheinlichkeit werden die energetisch schlechteren
Konfigurationen angenommen. Der dazu abgeleitete mathematische Formalismus
besitzt große Ähnlichkeit mit den Formeln einer physikalischen Theorie, die man als
Boltzmann-Statistik bezeichnet. Die Boltzmann-Statistik liefert für die statistische
Verteilung von Molekülen der Energie die Formel
p( E )    e  E /( k T )
p( E ) : Wahrscheinlichkeit für ein Molekül, daß es die Energie E besitzt.
k: Dimensionskonstante (Boltzmann-Konstante)
T: absolute Temperatur (eine mittlere Temperatur für alle Teilchen)
Offenbar folgt aus der vorstehenden Formel für 2 Energiezustände E 1 und E0:
(E E )
 0 1
p( E0 )
 e k T
p ( E1 )
E0-E1: Energieunterschied
k: Boltzmann-Konstante
T: Temperatur
2.6.4.3 Der Simulated-Annealing Algorithmus
Der Algorithmus läßt sich folgendermaßen beschreiben:
Wähle eine Anfangskonfiguration;
Wähle eine Anfangstemperatur T > 0;
wiederhole
wiederhole
Wähle eine neue Konfiguration, die eine kleine Änderung
der alten Konfiguration ist;
Berechne die Energiefunktion der neuen Konfiguration;
DE := E(neu) - E(alt);
wenn DE < 0, dann alte_Konfiguration := neue_Konfiguration
 DE
kT
sonst wenn Zufallszahl < e
,
dann alte Konfiguration := neue Konfiguration
bis lange keine Erniedrigung der Energie;
Verringere T;
155
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
bis keine Verringerung der Energiefunktion mehr auftritt;
Bsp.: Übertragung des Travelling Salesman Problem auf den Simulated Annealing
Algorithmus68
Das Travelling Salesman Problem (TSP) besteht darin, die kürzeste Rundreise
zwischen beliebig vielen Städten (Orten) zu finden 69. Zur Lösung des Problems ist
bisher kein Algorithmus bekannt, dessen Lösungszeit nur mit einer Potenz der
Anzahl N der Städte anwächst. Die Rechenzeit nimmt exponentiell zu (, d.h. ist
stärke als jede Potenz). Bei großen Problemen ist man auf "heuristische Verfahren"
angewiesen.
Nach den vorstehenden Ausführungen zum Simulated Annealing werden

( E0  E1 )
energetisch schlechtere Konfigurationen mit einer Wahrscheinlichkeit von e k T
angenommen. In der Praxis bestimmt man eine Zufallszahl zwischen 0 und 1. Ist sie

( E0  E1 )
kleiner als e k T , dann wird die energetisch schlechtere Konfiguration zum neuen
Systemzustand.
An die Stelle der Energien treten im TSP Entfernungen. Um die BoltzmannKonstante kümmert man sich aus Vereinfachungsgründen nicht, sondern drückt die
Temperatur direkt in Längeneinheiten aus. Wählt man bspw. als "Temperatur" eine
Entfernung, die größer ist als der größte Abstand von 2 Städten, dann wird beinahe
jede Veränderung der zufälligen Anfangsfolge mit hoher Wahrscheinlichkeit
akzeptiert werden, da p( E0  E1 ) nahe bei 1 liegt. Mit sinkender Temperatur sind nur
noch kleinräumige Variationen zugelassen. Bei T = 0 erstarrt die Lösung.
Kleinräumige Verbesserungen werden durch das "Verfahren von Lin" erreicht. Man
zerschneidet die Route an 2 zufällig bestimmten Stellen und setzt das
herausgetrennte Stück in umgekehrte Reihenfolge zusammen. Ist die Tour bspw. in
einem Array gespeichert, dessen letztes Element man sich mit dem ersten
verbunden denkt, dann ergibt sich für eine Tour mit "16 Städten":
Ausgangstour:
0
1
2
3
4
5 | 6
7
8
9
10 |11 12 13 14 15
" Schnitte" an der markierten Stelle ("|") führen zu:
0 1 2 3 4 5 10
bzw.
0 15 14 13 12 11 6
9
8
7
6 11 12 13 14 15
7
8
9 10
5
4
3
2
1
Nach Anbringen der Schnitte wird geprüft, ob die neue Tour als Variante akzeptiert
wird.
2.6.4.4 Das Applet zur Lösung des TSP mit Simulated Annealing
http://fbim.fh-regensburg.de/~saj39122/doerei/TSP.html
68
vgl. Otto, Thomas: Reiselust in c't 1994, Heft 1
Verwandte Aufgaben: Plazierung von logischen Gattern auf einen Chip; der Aufbau eines Service- und
Telefonnetzes
69
156
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.4.5 Threshold Accepting (TA) (Schwellenakzeptanz)
1990 veröffentlichten Dueck und Scheuer eine Variante zum Simulated Annealing
(SA). Während der SA-Algorithmus energetisch günstige Variationen sofort und
ungünstigere mit einer gewissen Wahrscheinlichkeit annimmt, akzeptiert TA alle
Variationen, bei denen die Änderung unterhalb eines positiven Schwellenwerts
bleibt.
Wähle eine Anfangskonfiguration;
Wähle eine Anfangstemperatur T > 0;
wiederhole
wiederhole
Wähle eine neue Konfiguration, die eine kleine Änderung
der alten Konfiguration ist;
Berechne die Energiefunktion der neuen Konfiguration;
DE := E(neu) - E(alt);
wenn DE < T, dann alte_Konfiguration := neue_Konfiguration
bis lange keine Erniedrigung der Energie;
Verringere T;
bis überhaupt keine Verringerung der Energiefunktion mehr
auftritt;
Man muß allerdings einen optimalen Fahrplan für die Erniedrigung der Temperatur
ermitteln, um möglichst rasch zu Ergebnissen zu kommen. Dueck stellte deshalb
noch einen weiteren Algorithmus vor.
157
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.6.5 Boltzmann Maschine
2.6.5.1 Beschreibung
Dieser Netzwerktyp wurde 1985 von Ackley, Hinton und Sejnowski entwickelt und
beinhaltet eine Weiterentwicklung des Hopfield-Netzes. Die Abruf-Phase erfolgt über
"simuliertes Kühlen", ein Lernverfahren zum Ermitteln der Gewichtswerte ist
vorgesehen.
1. Netztopologie
Der Aufbau des Boltzmann-Netzes ist übereinstimmend mit dem eines HopfieldNetzes: N vollständig vernetzte Neuronen mit Rückkopplung. Für die Gewichte gilt:
wij  wij für alle i  j
wii  0
für alle i
Die Neuronen des Netzes werden in 3 Klassen eingeteilt: Eingabeneuronen,
Ausgabeneuronen und verdeckte Neuronen. Sie nehmen die Zustände 0 und 1 an.
Die Umgebung beeinflußt niemals direkt die Aktivitäten der verdeckten Zellen. Diese
Zellen sollen Strukturen im Eingangsvektor entdecken, die nicht durch paarweise
Beziehung seiner Komponenten ausgedrückt werden können. Je nach Komplexität
des Problems benötigt man mehr oder weniger verdeckte Elemente.
Der Eingabe-Vektor wird angelegt, indem man die Zustände der Eingabezellen
entsprechend den Komponenten des Eingabevektors setzt. Während der gesamten
Zeit, die das Netz zum Antworten benötigt, dürfen die Eingabezellen ihre Zustände
nicht verändern.
Ein eindeutiger Ausgabezustand kann aus den Ausgabeeinheiten abgelesen
werden, sobald sich deren Aktivität nicht mehr verändert. Die Ausgabeeinheiten
haben dann einen stabilen Zustand erreicht. Die verdeckten Zellen können ihre
Aktivitäten weiter anpassen.
2. Dynamik und Energiefunktion
Die Boltzmann-Maschine ist ein stochastisch schaltendes Hopfieldnetz.
Die Dynamik der Boltzmann-Maschine gleicht der des Simulated Annealing
(Ausnahme: Während der Abrufphase dürfen die Zustände der Eingabeeinheiten
nicht verändert werden).
Eine zufällig ausgewähltes Neurom wird mit der Wahrscheinlichkeit p aktiv:
p ( oi  1) 
1 e


1
( wij o j ( t )   i )/ T
Auch die Energiefunktion hat für die Boltzmann-Maschine diesselbe Form:
158
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
E
1
 wij  oi  o j  i  i  oi
2 i j
3. Das Lernverfahren
Man führt "simuliertes Kühlen" durch
1. nur für die verborgenen Zellen durch Anlegen der Ein-, Ausgabewerte der zu
lernenden Funktion an die Ein-, Ausgabezellen (Plus-Phase). Während der PlusPhase dürfen alle sichtbaren Zellen ihre Zustände nicht ändern.
2. für das vollständige Netz. Während dieser Minus-Phase legt man ein zufälliges
Muster an und erlaubt auch den sichbaren Zellen, ihren Zustand zu ändern. Das
Netz läuft frei.
Beide Kühlungen werden abwechselnd vorgenommen und die Gewichte so
angepaßt, daß die beiden Vorgänge sich annähern.
Ziel des Lernalgorithmus ist es, Gewichte so einzustellen, daß 2 Zellen im
(thermischen) Gleichgewicht immer mit derselben Wahrscheinlichkeit aktiv sind,
unabhängig davon, ob das Netz in der positiven oder in der negativen Phase läuft.
Diesem Idealzustand versucht man durch die Lernregel so nahe wie möglich zu
kommen. Man nennt diesen Lernalgorithmus "maximum likelyhood", d.h.: Gewichte
werden so bestimmt, daß jeder Zustand im Netz mit angelegter Eingabe diesselbe
Wahrscheinlichkeit hat, wie wenn die Boltzmann-Maschine von einem zufällig
gewählten Anfangszustand aus frei läuft.
Ist die zu lernende Funktion
ok  F (ik )
ok : Ausgabevektoren
ik : Eingabevektoren
und läßt sich der Zustand des Netzes beschreiben durch
Zk  (a1 ,......, an )
( ai {0,1})
und ist
Zk
Zk


der Netzzustand, der durch simuliertes Kühlen entsteht, falls man einen
Eingabe- und einen Ausgabevektor an die Ein-/Ausgabezellen legt und diese
Zellen während des Kühlens nicht verändert (Kühlen nur für verdeckte Zellen,
Plus-Phase)
der Netzzustand, der durch simuliertes Kühlen entsteht, falls man das gesamte
Netz frei laufen läßt,
dann ist eine Anpassung des Netzes an die zu lernende Funktion erreicht, falls das
Netz die Gewichte so gelernt hat, daß

pk  pk

ist.
159
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen


pk : Wahrscheinlichkeit für den Zustand Zk


pk : Wahrscheinlichkeit für den Zustand Zk
Da beim Kühlen (Minus-Phase) Energieminima und damit Zustände hohe
Wahrscheinlichkeit angesteuert werden, ist pk  groß und damit auch pk  groß. Falls


pk  pk gilt, wird mit hoher Wahrscheinlichkeit der im Sinne der zu lernenden
Funktion richtige Ausgabebereich zugeordnet.
4. Abruf-Phase
Eingabewerte werden an Eingabeneuronen angelegt. Dann führt man simuliertes
Kühlen durch und zwar solange, bis die Ausgabeneuronen sich nicht mehr ändern.
Während des Kühlvorgangs dürfen die Eingabezellen nicht mehr verändert werden.
Danach kann man die Ausgabewerte an den Eingabezellen ablesen. Jedem
Eingabevektor läßt sich beim Abruf so ein Ausgabevektor zuordnen. Offensichtlich
wurde eine Funktion im Netz gespeichert.
2.6.5.2 Der Algorithmus
(1) Definiere die Gewichte wij und i durch Zufallszahlen
(2) Berechne N Zustände




Zk  (ak1 , ak 2 ,..., akn )
1



(3) Berechne pij   a ki  a kj
N k
(4) Berechne N Zustände




Zk  (ak1 , ak 2 ,..., akn )
1



(5) Berechne pij   a ki  a kj
N k
(6) Korrigiere Gewichte durch




Z1 ,..., Zn
mit
den
Neuronenbelegungen
mit
den
Neuronenbelegungen

wij
neu
 wij    ( pij  pij ) mit   0
i
neu

alt


 i    ( pi  pi ) mit pi 
alt

Z1 ,..., Zn
1
N
a

k
k
(7) Weiter bei (2)
Aus der Korrekturformel für die Gewichte (6) erkennt man, daß für die
Energiefunktion
E
1
  wij  a j  ai  i i  ai
2 i j

- Energietäler, die die Funktion ok  F (ik ) unterstützen vertieft werden ( pij )
160
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen

- Energietäler, die nicht der Funktion entsprechen, nivelliert werden ( pij )
Die Lernrate   0 gibt an, wie stark ein Durchlauf (sweep) des Lernalgorithmus in die
Änderung der Gewichte eingeht. Ist  zu groß, so zeigt die Lernregel oszillierdnes
Verhalten: Die Gewichte werden so stark verändert, daß nach dem nächsten
Lernschritt eine Änderung in umgekehrter Richtung notwendig ist. ein kleines 
verzögert den lernprozeß und erhöht den Zeitaufwand.
Günstig ist es,  im Laufe des Lernprozesses allmählich zu verkleinern. Während
der beiden Phasen darf die Temperatur nicht so klein werden, daß das Netz einfriert.
Andererseits soll die Temperatur aber so niedrig sein, daß die Abstände der
tatsächlich angenommenen Zustände vom stabilen Zustand nicht allzu groß sind.
2.6.5.3 Implementierung
1. Erlernen einer Funktion
Das folgende Implementierungsbeispiel (in Form eines Applets) soll zeigen, wie eine
Boltzmann-Maschine eine Funktion erlernen kann. Die zu erlernende Funktion ist in
der folgenden Prozedur Boltztest.Funktion(int index) festgelegt:
public void Funktion(int index){
for (int i = 0; i < NN.AnzNeurE; i++)
if (i ==index)
Eingabe[i] = 1;
else
Eingabe[i] = 0;
for (int i = 0; i< NN.AnzNeurA;i++)
if (Eingabe[i] == 1 )
Ausgabe[i] = 0;
else
Ausgabe[i] = 1;
}
Die Funktion bewirkt eine Invertierung von Bitfolgen (vom Eingabevektor Eingabe
zum Ausgabevektor Ausgabe). Als Eingabe werden nur Bitfolgen zugelassen, bei
denen genau ein Neuron 1 und alle anderen 0 gesetzt sind.
Bsp: Eingabe = 010 soll in Ausgabe = 101 umgewandelt werden.
161
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Darstellung der Boltzmann-Maschine
Im Applet sind die Neuronen der Boltzmann-Maschine sowie die Verteilung der
Energie auf ihre Zustände Z dargestellt.
Um alle Zustände Z der Boltzmann-Maschine darstellen zu können, wurde ein sehr
kleines Netz gewählt, welches wie folgt aufgebaut ist:
2 verborgene Neuronen
3 Ausgabe Neuronen
3 Eingabe Neuronen
Da die Neuronen nur die Werte 1 oder 0 haben können, ergeben sich mit diesen n =
8 Neuronen also insgesamt N = 2n also 256 mögliche Zustände dieses Netzes.
Zustand
1
2
3
...
32
64
84
128
...
256
Verborgene Neuronen
10
01
11
...
00
00
00
00
...
11
Ausgabe Neuronen
000
000
000
...
000
000
101
000
...
111
Eingabe Neuronen
000
000
000
...
100
010
010
001
...
111
Für jeden dieser Zustände Z kann nun eine Energie E(Z) des Netzes berechnet
werden. Zur Darstellung der Energieverteilung über alle möglichen Zustände der
Boltzmann-Maschine wird für jeden der 256 Zustände dessen Energie berechnet.
Die folgende Prozedur Boltztest.paintEnergie() wandelt i (Zähler über alle
Zustände) in eine Binärzahl um und belegt die Aktivitäten des Netzes (NN.A[ ]) mit
dieser Binärzahl. Anschließend wird dann die Energie in der Prozedur
Boltzmann.berechneNetzEnergie() ermittelt. Im Feld Energie[] werden die
Energiewerte zur Darstellung im Diagramm abgelegt. Maxenergie ist der größte
Energiewert im Diagramm.
public void paintEnergie(){
int max ;
double m,m2;
max =(int) java.lang.Math.pow(2.0,(float)(NN.AnzNeur-1));
//über alle möglichen zustände
for (int i = 0; i<max ; i++){
m =i;
//i in Binärzahl umwandeln und A belegen
for (int j = NN.AnzNeur-2; j >=0 ;j--){
m2 = java.lang.Math.pow(2.0,(float)(j));
if ( m/m2 >= 1)
NN.A[j] = 1;
else
NN.A[j] = 0;
m = m%m2;
}
NN.berechneNetzEnergie();
Energie[i] = Maxenergie - NN.Energie;
}
}
162
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
In der Prozedur Boltzmann.berechneNetzEnergie() wird die Energie für den
aktuellen Zustand des Netzes berechnet.
public void berechneNetzEnergie(){
Energie = 0;
cEnergie = 0;
for (int i = 0; i < AnzNeur;i++)
for(int j = 0; j <i ; j++){
Energie = Energie +W[i][j]*A[i]*A[j];
cEnergie = cEnergie + W[i][j]*Ac[i]*Ac[j];
}
}
Die Energiewerte können nun in einem Diagramm70 dargestellt werden und
veranschaulichen die "Energie Landschaft" des Netzes. Das folgendes Bild zeigt
eine Energieverteilung nach Initalisierung (Ruecksetzen) des Netzes.
3. Simulated Annealing
Simulated Annealing wird bei der Boltzmann-Maschine dazu benutzt, globale
Minima aufzufinden. In so einem "Tal" der Energiefunktion finden sich die Zustände
für die Lösung der gelernten Funktion wieder. Bei jedem Lernzyklus wird für jedes
Musterpaar von Eingabe und Ausgabe simuliertes Kühlen durchgeführt. Das Kühlen
wird pro Muster zweimal durchgeführt:
Einmal dürfen sich hierbei die Neuronen der Eingabe- und Ausgabeschicht nicht
ändern (Fall 1, Z+) man spricht hierbei vom Festklemmen besagter Neuronen.
Im anderen Fall dürfen sich alle Neuronen frei verändern (Fall 2, Z-), das Netz läuft
frei.
Fall 1 schränkt also die möglichen Zustände des Netzes ein. Nur noch die
verborgenen Neuronen sind beweglich und somit kann nur ein minimaler Zustand im
Bereich der möglichen Zustände aufgesucht werden.
Beispiel: Zustand Z = XX 011 010 (X = bewegliches Neuron) ergibt einen
möglichen (eingeschränkten) Zustandsbereich von Z1 = 00 011 010 bis Z2 = 11
011 010 also von Z1 = 88 bis Z2 = 91
70
Im Applet gibt es 2 Diagramme. Beide zeigen die gleichen Energiewerte des Netzes an. Im oberen Diagramm
werden aber auch die Zustände des festgeklemmten Netzes dargestellt, im unteren die des frei laufenden Netzes.
163
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Das simulierte Kühlen für die Boltzmann-Maschine kann wie folgt beschrieben
werden.
Aktivierung der Neuronen auf Eingabewerte setzen
(festklemmen oder nicht), dann folgende Iteration ausführen.
wiederhole
für jedes Neuron k
Mit Wahrscheinlichkeit pk setze Zustand auf 1, sonst auf 0
reduziere T nach einer bestimmten Funktion (z.B Gerade, oder T =
1/i, i Zeitschritte)
In folgender Prozedur Boltzmann.kuehlen() wird das Kühlen durchgeführt. Wie
lange gekühlt wird, hängt von AnzKuehlZyklen ab (nicht zu verwechseln mit
Anzahl der Lernzyklen). Die Temperatur T wird in diesem Fall linear abgesenkt. (An
dieser Stelle könnte man auch eine andere Kühlfunktion wählen.)
A[ ] enthält die Zustände Z- des Netzes im freien Zustand (Fall 2). Ac[ ] enthält
die Zustände Z+ des Netzes im festgeklemmten Zustand (Fall 1).
public void kuehlen(){
double deltaE;
int bis = AnzNeur -1;
if (clamped)
bis =AnzNeurV;
for (int i = 1; i< AnzKuehlZyklen; i++){
// langsam(bei jedem durchlauf) T von 1 gegen 0 senken
T = (float)(AnzKuehlZyklen-i)/(float)AnzZyklen;
for (int j = 0; j < bis; j++){
deltaE = berechneEnergie(j);
// delta Energie des j-ten
berechnen
if (clamped)
Ac[j] = Aktivieren(deltaE);
// j-tes Neuron aktivieren
else
A[j] = Aktivieren(deltaE);
// j-tes Neuron aktivieren
}
}
}
Neurons
Beim Aufruf der Funktion Boltzmann.berechneEnergie(j) wird die
Energiedifferenz berechnet, die entsteht, wenn das Netz von einem Zustand in
einen anderen wechselt, wobei sich nur das Neuron j verändert, aber alle anderen
gleich bleiben.
public double berechneEnergie(int index){
double deltaE = 0;
int bis = AnzNeur -1;
if (clamped)
bis = AnzNeurV;
for (int i = 0; i < bis; i++)
if (clamped)
deltaE = deltaE + W[i][index]*Ac[i];
else
deltaE = deltaE + W[i][index]*A[i];
return deltaE;
}
Die
stochastische
Aktivierungsfunktion
ist
in
der
Funktion
Boltzmann.Aktivieren() implementiert. Dabei ist die Aktivierung eines Neurons
unabhängig von seinem vorherigen Zustand. Anzumerken ist, daß nicht etwa der
Wert der Aktivierungsfunktion durch eine Zufallszahl bestimmt wird, sondern die
Wahrscheinlichkeit, mit der das zu aktivierende Neuron auf 1 gesetzt wird. Als x wird
164
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
die Energiedifferenz für die Änderung des Neuronenzustands übergeben. Eine große
positive Energiedifferenz erhöht also die Wahrscheinlichkeit, daß das Neuron
aktiviert wird.
public double Aktivieren(double x ){
if ( java.lang.Math.random() < (1/(1+java.lang.Math.exp(-x/T)))
return 1;
else
return 0;
}
)
4. Lernen
Ziel des Lernverfahrens ist es, die Gewichte so einzustellen, daß es im
Temperaturgleichgewicht ohne externe Eingabe mit gleicher Wahrscheinlichkeit die
Zustände erreicht, die es bei festgeklemmter Eingabe erreicht.
Die Zustände minimaler Energie, die aufgesucht werden, wenn Eingabe und
Ausgabe festgeklemmt sind (Fall 1, Z+), sollen also auch ohne Festklemmen der
Eingabe (Fall 2, Z-) aufgefunden werden.
Die "Energietäler" bei den Zuständen bei festgeklemmter Eingabe und Ausgabe
sollen also vertieft werden, andere Minimas nicht.
Da bei diesem Beispiel nur 3 Eingabe- und 3 Ausgabeneuronen existieren, liefert die
Funktion Boltzmann.Funktion() 3 Musterpaare ( Eingabe: 001- Ausgabe: 110 ,
E: 010 - A: 101 und E: 100 - A: 011) zum Training des Netzes.
Während des Trainings des Netzes im Applet kann man beobachten, wie sich
besagte "Energietäler" zunehmend vertiefen. Das obere Diagramm zeigt die
Zustände (grün), die bei festgeklemmter Eingabe und Ausgabe erreicht werden. An
diesen Stellen werden auch die "Energietäler" entstehen. Das untere Diagramm zeigt
die Zustände des freilaufenden Netzes (rot). Bei zunehmender Trainingszeit
beobachtet man, daß sich auch im unteren Diagramm immer häufiger die Zustände
wie im Diagramm darüber einstellen. Das Netz findet also auch die gesuchten
Zustände wieder, wenn es frei läuft.
Das Lernverfahren kann wie folgt beschrieben werden.
1.Berechne die Wahrscheinlichkeiten pij+ bei festgeklemmter Eingabe
Setze sumij = 0 ( Anzahl der gleichzeitigen Aktivierung von ai und
aj)
Für jeden der n Trainingsvektoren führe aus
- Aktivierung der Neuronen auf Trainingsvektor festklemmen
- Simuliertes Kühlen durchführen
- Für alle Neuronenpaare i, j setze sumij = sumij + ai*aj
Berechne die Wahrscheinlichkeit pij+ = sumij/n
2.Berechne die Wahrscheinlichkeiten pij- bei freilaufendem Netz
Setze sumij = 0 ( Anzahl der gleichzeitigen Aktivierung von ai und
aj)
Für jeden der n Trainingsvektoren führe aus
- Simuliertes Kühlen durchführen
- Für alle Neuronenpaare i, j setze sumij = sumij + ai*aj
Berechne die Wahrscheinlichkeit pij- = sumij/n
3.Korrigiere die Gewichte wij = wij + epsilon*(pij+
- pij-)
In der Prozedur Boltztest.Training() ist der Lernalgorithmus enthalten. (Im
Applet Source-Code sind an dieser Stelle noch Funktionen zur Ausgabe der
Diagramme etc. eingefügt.)
for (int i = 0; i < TrainingsCyclen;i++)
165
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
{
NN.resetSumme(); // sumij = 0 für alle i, j
for (int j = 0; j < AnzTrainingspaare ; j++)
{
Funktion(j); //Eingabe u. Ausgabe werden gesetzt
setInpPattern();
NN.FeedForward();
NN.berechneSummeP();
}
NN.berechneP(AnzTrainingspaare );
NN.aendereGewichte();
}
In Prozedur Boltztest.setInpPattern() wird das in Eingabe und Ausgabe
abgelegte Trainingsmusterpaar auf die Eingabe- und Ausgabeneuronen gelegt.
public void setInpPattern(){
NN.clamped = true;
NN.setzeEingabe (Eingabe);
NN.setzeZiel(Ausgabe);
NN.clamped = false;
NN.setzeEingabe (Eingabe);
NN.setzeZiel(Ausgabe);
}
In Boltzmann.FeedForward() werden zwei Kühlschritte durchgeführt. Einmal bei
festgegklemmten Zustand, einmal bei freilaufendem Netz.
public void FeedForward(){
clamped = true; //Eingabe u. Ausgabe Neuronen "festklemmen"
kuehlen();
clamped = false; //Netz läuft frei
kuehlen();
}
Die Prozedur Boltzmann.berechneSummeP() summiert die gleichzeitige
Aktivierung der Neuronenpaare i, j auf.
Bemerkung: Variablen, die mit c enden, wie z.B sumc[ ][ ], Ac[ ],... , werden
immer mit Werten belegt, die im festgeklemmten Zustand ermittelt wurden.
public void berechneSummeP()
{
for (int i = 0; i < AnzNeur; i++)
for ( int j = 0; j< AnzNeur; j++)
if (j!=i){
if ( Ac[i]*Ac[j] == 1) sumc[i][j] = sumc[i][j]+1;
if (A[i]*A[j] == 1)
sum[i][j] = sum[i][j]+1;
}
}
In der Prozedur Boltzmann.berechneP(int AnzPaare) werden jetzt die
Wahrscheinlichkeiten pij+ und pij- aus sum[][] und sumc[][]berechnet.
public void berechneP(int AnzPaare){
for (int i = 0; i < AnzNeur; i++)
for (int j = 0; j< AnzNeur;j++){
Pc[i][j] = sumc[i][j]/(float)AnzPaare;
P[i][j]
= sum[i][j]/(float)AnzPaare;
}
}
In Boltzmann.aendereGewichte() werden schließlich die Gewichte adaptiert.
166
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
public void aendereGewichte(){
deltaW = 0;
for (int i = 0; i < AnzNeur; i++)
for (int j = 0; j < AnzNeur; j++){
deltaW =Epsilon*(Pc[i][j] -P[i][j]) ;
W[i][j] = W[i][j] + deltaW;
}
}
2.6.5.4 Das Applet
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/fi-bolz/
167
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.7 Wettbewerbslernen (Competitive Learning)
Typische Aufgabenstellung: Cluster-Analyse auf der Basis Neuronaler Netze (NN).
Zur Lösung dieser Aufgabe werden NN mit zwei Schichten verwendet:

x
x1
x2
xn
.......
w11
Eingabeschicht
wm1
wmn
w12
wm2
.............
y1
Wettbewerbsschicht
ym

y
Abb. 2.7-1: Kompetitives Netz
Eingabeschicht: Die Anzahl der Neuronen dieser Schicht entspricht der Anzahl der
Komponenten der zu untersuchenden Daten. Die Werte des Eingabemusters
werden an die zweite Neuronenschicht weitergeleitet.
Wettbewerbsschicht: Durch diese Schicht wird die Anzahl der Klassen oder Cluster
festgelegt, in die die Daten eingeteilt werden. Jedes Neuron dient zur Repräsentation
einer Klasse. Welche Klasse einem bestimmten Neuron zugeordnet wird, legen die
Gewichte fest, die die Neuronen der Eingabeschicht mit diesem Neuron verbinden.
Das Neuron, das die größte Übereinstimmung seiner Gewichtsinformation mit dem
Eingabemuster feststellt, erhält die Aktivierung 1, allen anderen Neuronen der
zweiten Schicht wird der Wert 0 zugeordnet. Falls nicht eindeutig bestimmt werden
kann, welches Neuron die größte Übereinstimmung mit ihrer Gewichtsinformation
ergibt, dann sollte zufällig eines der Neuronen mit maximaler Übereinstimmung
ausgewählt werden. Das Neuron, das die Aktivierung 1 erhält, wird als Sieger
(winner) bezeichnet. Die Auswahl eines einzelnen Neurons mit Aktivierung 1 und
Unterdrückung der Aktivierung aller anderen Neuronen, nennt man das WinnerTake-All-Prinzip.
Berechnung der Übereinstimmung zwischen Gewichtsinformation eines Neurons und
eines Eingabemusters:
n
 
x T  w j   wij  xi
i 1
Die Gewichte, die von der Eingabeschicht zu einem Neuron j der Wettbewerbsschicht führen, lassen
 w j1 



sich als n-dimensionaler Vekor w j   ...  auffassen (reellwertige Gewichtsvektoren). Die Norm
w 
 jn 
2


 T 
aller w j ist gleich 1: w j  w j  w j  1
168
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Wegen der Normierung erhält man als Übereinstimmungsmaß den Cosinus des Winkels zwischen
Eingabe- und Gewichtsvektor. Je kleiner dieser Winkel ist, desto eher wird das entsprechende Neuron
als Sieger hervorgehen. Der größtmögliche Übereinstimmungswert wird nur auftreten, wenn Eingabeund Gewichtsvektor identisch sind.

Gewinner ist bei der Eingabe von x das Neuron, dessen Gewichtsvektor am


nächsten bei x liegt Sein Gewichtsvektor wird ein kleines Stück näher an x
herangerückt.


x (t )  w j (t )

w j (t )

w j (t  1)

x (t )
Abb.:
Erlernen der Gewichte: Die Gewichtsvektoren des Siegerneurons werden nach dem
Verarbeiten des vorgegebenen Eingabevektors so verändert, dass sich bei erneuter
Präsentation desselben Eingabevektors eine noch bessere Übereinstimmung für
diese Neuron ergibt. Neuer Gewichtsvektor könnte sein:


w j* (t )  x

w j* (t  1)  

w j* (t )  x
Der resultierende Vektor halbiert offenbar den Winkel von zwischen dem

Eingabevektor x und dem bisherigen Gewichtsvektor, so dass sich bei erneuter
Präsentation ein kleinerer Winkel und somit eine größere Übereinstimmung

zwischen x und dem neuen Gewichtsvektor ergibt.
Allgemein kann anstelle der angegebenen Formel auch



w j* (t )   x (t )  w j* (t ) 





w j* (t  1)  w j* (t )   x (t )  w j* (t )  bzw. w j* (t  1)  


w j* (t )   x (t )  w j* (t ) 

j*: Index vom Gewinnerneuron bei der Präsentation von x .
0    1 ist die Lernrate, die bestimmt, wie stark der Gewichtsvektor vom Eingabevektor angezogen
wird.
verwendet werden.
Die Gewichtsvektoren der anderen Neuronen bleiben unverändert.
Falls sich die Gewichtsvektoren des Neuronalen Netzes durch das
Wettbewerbslernen so eingestellt haben, dass sich jedes Neuron in der
Wettbewerbsschicht eine feste Menge Eingabevektoren "erobert" hat, für die es als
Siegerneuron hervorgeht, springt der Gewichtsvektor beim Lernen ständig zwischen
den eroberten Eingabevektoren hin und her. Zum Vermeiden bzw. Verringern dieses
Effekts wird die Lernrate nicht konstant gewählt, sondern während des Lernens
ständig verkleinert, bis sie schließlich den Wert Null erreicht oder einen Wert nahe 0
unterschritten hat, was der Beendigung des Lernvorgangs entspricht.
Arbeitsweise:
-
Anlegen eines Eingabevektors

x
169
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
n
Auf jedes Ausgabeneuron j wirkt dann
w
i 1
-
ij


(t )  xi (t ) x (t ) T  w j (t )
Auswahl des Gewinnerneurons (Voraussetzung: auf 1 normierter Gewichtsvektor)


wj  x
2

T 

 

2
 w j  x   w j  x   w j  2 x T w j  x
2
 

 1  2x T w j  x
2
 
Demnach ist die Auswahl des Neurons j mit dem größten Skalarprodukt x T  w j

gleichbedeutend mit der Auswahl des Neurons j*, dessen Gewichtsvektor w j dem

Eingabevektor x am nächsten liegt.
Clusterung: Das Erkennen der Clusterung ist in höherdimensionalen Räumen
weitaus schwieriger, als es ein zweidimensionales Netz vermuten lässt. In vielen
Fällen wird man ein selbstorganisierendes Netz verwenden, das so viele
Ausgabeneuronen hat, wie man Klassen hat. Man hofft, dass sich die jeweiligen
Gewichtsvektoren
dieser
Ausgabeneuronen
bei der Präsentation
der
Eingabevektoren in das Zentrum einer der Klassen hinein bewegen. Am Ende stellt
der Gewichtsvektor eines jeden Ausgabeneurons ein Prototyp für eine Klasse dar.
Diese Verfahrensweise ist unter der Bezeichnung Learning Vector Quantization
(LVQ) bekannt.
Vector Quantization ist die wichtigste Anwendung des konkurrierenden Lernens.

Dabe werden die Eingabevektoren x in Klassen kategorisiert und durch den Index
der Klasse repräsentiert. Dieses Verfahren eignet sich gut zur Datenkompression,
denn es braucht nicht mehr der der "große" Vektor übertragen oder gespeichert
werden, sondern nur dessen Index. In einem Codebuch kann man den
Repräsentations-Vektor nachschlagen.
Hat man durch Selbstorganisation die Gewichtsvektoren als Prototypen von Clustern
ausgebildet, so hat man dadurch noch keine Information darüber, ob zwei Cluster
eher näher beieinander liegen oder voneinander weiter entfernt sind. Solche
Information würde man erhalten, wenn man die Ausgabeneuronen noch mit einer
"Nachbarschaftsstruktur versehen hätte, die nach dem Training Ähnlichkeiten im
Eingaberaum widerspiegelt. Diese zusätzliche Idee liegt den selbstorganisierenden
Karten (Self Organizing Maps, SOMs) von Kohonen zugrunde.
170
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8 Selbstorganisierende Netze
2.8.1 Sensorische Karten (SOMs)
Bei Selbstorganisierenden Karten handelt es sich um ein spezielles Neuronales
Netz, das sich selbst organisiert, also im Gegensatz zum Perzeptron ohne Lehrer
arbeitet. Ein weiteres spezifisches Merkmal der SOMs ist, dass auch die räumliche
Anordnung der Neuronen untereinander eine wichtige Rolle in Lernverfahren spielt.
2.8.1.1 Beschreibung
1. Einführung
Sensorische Karten sind Modelle NN, die die Fähigkeiten des Gehirns zur
Selbstorganisation nachahmen und ihre Verbindungsstruktur gemäß einfachen
Regeln selbst organisieren. Von Rezeptoren erhält eine Schicht interner Neuronen
(sensorische Karte) Signale. Die Erregung der Neuronen konzentriert sich auf ein
räumlich begrenztes Gebiet der Karte. Je ähnlicher zwei Eingaben sind, desto näher
liegen die dadurch aktivierten Neuronen beieinander. Einander ähnliche
Eingabevektoren werden in der SOM auch beieinander dargestellt. Nach der
Lernphase bildet die Karte den Merkmalsraum der Eingabesignale in seinen
Ähnlichkeitsbeziehungen räumlich korrekt ab.
Kohonen formulierte das mathematische Modell (Kohonen Feature-Map) eines
selbstorganisierenden Prozesses, der eine solche Abbildung leistet.
2. Aufbau der Kohonen Feature-Map
Selbstorganisierende Karten sind Netze mit nur einer Schicht aktiver Neuronen
(Kohonenschicht, Kohonen Feature Map, selbstorganisierende Karte (SOM)), die
gleichzeitig die Ausgabeschicht bildet und eine Schicht von Eingabeneuronen. Jedes
Eingabeneuron ist mit jedem Neuron der Kartenschicht verbunden. Neuronen der
Kohonenschicht bilden im Gegensatz zu dem schichtenweise aufgebauten
Feedforward-Netzen
ein
m-dimensionales
Gitter
mit
lokalen
Nachbarschaftsbeziehungen. Meistens wird ein quadratisches oder hexagonales
Gitter gewählt. Manchmal benutzt man auch eindimensionale Ketten oder
dreidimensionale Gitter.
171
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Eingabe
Eingabeneuronen
Nachbarschaftsbeziehungen
(Rückkopplungskoeffizienten)
Abb. 2.8-1: Netz mit Eingabe und Rückkopplung
Von einer Eingabeschicht wird Aktivierung ausgebreitet zu einer in der Regel
zweidimensionalen Ausgabeschicht (eigentliche sensorische Karte). Die
Kartenschicht ist auf sich selbst zurückgekoppelt, d.h.: Jedes Neuron der Karte ist
mit sich selbst wechselseitig verbunden. Innerhalb der Kartenschicht ist jedes
Neuron i durch seine Koordinaten "x" und "y" bestimmt.

Jedes Kohonenneuron „j“ besitzt einen Gewichtsvektor: w j  (w1 j , w2 j ,..., wnj ) . Je

Eingabeneuron kann ein Wert xi verarbeitet werden. Der Eingabevektor x umfasst
die Komponenten: ( x1 , x2 ,..., xn ) . Beschränkt man sich maximal auf drei
Dimensionen, dann kann man sich sowohl die Eingaben als auch die Gewichte
anschaulich als Ortsvektoren vorstellen. Bspw. entsprechen bei einer rechteckigen
Karte mit zweidimensionale Eingabe sowohl die Gewichtsvektoren als auch die
Eingabevektoren ebenen Punktkoordinaten.
Die Gewichtsvektoren werden im Laufe des Trainingsprozesses so im ndimensionalen Raum angeordnet, dass sie die Eingabevektoren räumlich geordnet
repräsentieren. Infolge der Nachbarschaftsbeziehungen der Kohonen-Neuronen
verhalten sich deren Gewichtsvektoren wie ein elastisches Gitternetz. Durch
Änderung der Gewichte eines Neurons an einer Stelle werden auch die Gewichte der
Nachbarn beeinflusst. Das Training einer zweidimensionalen Karte mit zwei
Eingabeneuronen, also mit Eingabevektoren gleicher Dimension, kann man sich
bspw. sehr gut als eine Art allmähliches „In-Form-Ziehen“ eines realen Netzes
vorstellen71.
3. Knotendynamik

Je Lernschritt wird ein Eingabevektor x  ( x1 , x 2 ,..., x n ) präsentiert. Dieser wird mit
allen vorhandenn Gewichtsvektoren verglichen. Als Vergleichsmetrik werden dafür
entweder die Euklidische Norm oder für normalisierte Vektoren, das Skalarprodukt

verwendet. Das Neuron „c“, dessen Gewichtsvektor w c dem aktuellen Eingabevektor

x am ähnlichsten ist, gewinnt. Die Art der Ähnlichkeit ergibt sich aus der
Vergleichsnorm. Bei Verwendung der Euklidischen Norm und Betrachtung der
71
vgl. 2.8.1.3.2.2
172
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Gewichte als Ortsvekoren ist dies anschaulich betrachtet jenes Neuron, das der
Eingabe am nächsten ist.

x  wj

x

wj
Abb.: Minimale Euklidische Distanz zwischen einem Eingabevektor und einem Gewichtsvektor. Sie ist
nicht anderes als die Entfernung zweier Vektoren und ein Maß für die Ähnlichkeit
Für den Gewinner gilt allgemein:
 
 
x  wc  min j ( x  w j ) . Mit der Euklidischen
Distanz ermittelt sich der Gewinner folgendermaßen:
 
c  arg min j ( x  w j )  arg min j ( ( x1  w1 j ) 2  ...  ( xn  wnj ) 2
Verwendet man das Skalarprodukt und normiert die Vektoren zuvor, ergibt sich für
„c“:
 

x1  w1 j  ...  x n  wnj
x w
c  arg max j (    )  arg max j 

2
2
2
2
x w
 x1  ...  x n  w1  ...  wn




Nachdem der Gewinner ermittelt ist, erfolgt das Training von Gewinner-Neuron und
jenen Neuronen, die sich in topologischer Nachbarschaft befinden. Die
Nachbachschaftsfunktion beschreibt:
 
hcj (t )  h( rc  r j )  h( z, t )  h' ( z , d )
 
rc , r j : Position der Neuronen c und j im Neuronengitter.
t  1,2,... diskrete Zeitkonstante, die die zeitlich veränderbare Lernrate mit 0   (t )  1
mitbestimmt.
 
Aus der Differenz rc  r j ergibt sich die jeweilige Distanz des Neuron j zum
 
Gewinnerneuron c. Mit steigendem Abstand rc  r j gilt: hcj  0
Statt des Zeitparameters kann man alternativ einen Distanzparameter d verwenden,
der direkt die Größe der Reichweite angibt und für den gilt: d  0 für t   .
Die Größe des Nachbarschaftsradius ändert sich im Laufe des Trainingsprozesses.
Man beginnt mit einer relativ grossen Umgebung und lässt diese mit fortschreitenden
Trainin immer kleiner werden, bis zum Schluß nur das Gewinnerneuron übrig bleibt.



Das neue Gewicht w j (t  1)  w j (t )   (t )  hcj (t )  ( x (t )  w j (t )) ermittelt.
173
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.1.2 Lernverfahren: Bestimmen der Gewichte
Kinnebrock72 schlägt für die Implementierung des Lernverfhrens von Kohonen
folgende Vorgehensweise vor:
(1) Wähle alle wij über Zufallszahlen

(2) Gib einen Eingabevektor i vor (sensorisches Signal)
(3) Suche das Neuron („j“), für das  (ik  w jk ) 2 minimal ist.
k
Zur Ermittlung des Erregungszentrums schlägt Kohonen vor: Auswahl des
Neurons "j" mit der maximalen Netzeinwirkung aller isoliert betrachteten
Kartenneuronen
max  wij  oi 73. Falls alle Gewichtsklassen und alle
i
Eingabevektoren dem Betrag nach konstant sind, kann man für
w
ij
i

 
 oi

folgenden Hilfssatz anwenden: Das Skalarpodukt a  b zweier Vektoren a , b ist
maximal, falls  ( ai  bi ) 2 minimal ist.
i
Obwohl die Voraussetzung nicht exakt erfüllt ist, wird hier das Neuron gesucht, für
das  ( wik  ik ) 2 minimal ist.
k
Nach
der
Bestimmung
des
Erregungzentrums
Rückkopplungskoeffizienten so zu wählen:
"j"
sind
die
- Neuronenpaare, die im Gitter nahe beeinander liegen, erhalten große Werte zugeordnet
- Neuronenpaare, die im Gitter weiter voneinander entfernt sind, erhalten kleine Werte zugeordnet.
Den Grad dieser Beeinflussung beschreibt Kohonen für zweidimensionale
Neuronengitter durch:


rij  exp( ( x i  x j ) 2 / 2   2 )
 
xi , x j : Lagevektoren der entsprechenden Neuronen im Gitter
 2 : Varianz (zweidimensionale Gaußverteilung), bestimmt
die
räumliche
Ausdehnung der Glockenfläche, d.h.: den Radius des Einflusses eines Neurons
auf seine Nachbarn.
(4) Verbessere alle Gewichte wik durch wik (t  1)  wik (t )    rij  (ik  wik (t )) mit
(5) Weiter bei (2)
72
73
W. Kinnenbrock, Neuronale Netze, … S. 83
Voraussetzung: auf 1 normierte Gewichtsvektoren
174
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.1.3 Implementierungsbeispiele
2.8.1.3.1 Simulationsbeispiel mit eindimensionaler Eingabe
1. Aufgabe: „Eindimensionales Neuronengitter mit eindimensionalen Eingaben“
2. Applet:
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/fi-kohonen/kohonendemo.html
2.8.1.3.2 Simulationsbeispiele mit zweidimensionalen Eingaben
Es werden Netze mit 2 Eingabebits bearbeitet.
2.8.1.3.2.1 Eindimensionales Gitter der Neuronenkette
2.8.1.3.2.1.1 Streckenförmige Anordnung der Neuronenkette
.
.
.
.
Abb.: Kette mit n Eingabeneuronen und m Ausgabeneuronen
1. Aufgabenstellung
Betrachtet wird ein Kohonen-Netz, das eine eindimensionale Neuronenkette und
zweidimensionale Eingaben verwendet, d.h. Jedem Neuron i sind die Gewichte w ix
und wiy zugeordnet. Beide Zahlenwerte sind einem Punkt der Ebene (x-Koordinate,
y-Koordinate) zugeordnet.
Am Anfang des Lernverfahrens sind den Neuronen zufällige Punkte zugeordnet.
Verbindet man die Punkte in der Reihenfolge der Neuronen in der Kette, dann
überschneiden sich die Verbindungslinien, es ist keine Ordnung erkennbar. Im
weiteren Ablauf des Lernverfahrens ergeben die Punkte in der Reihenfolge wie die
zugehörigen Neuronen in der Kette stehen, eine Kurve. Diese Kurve wird immer
länger und überdeckt schließlich die ganze Zeichenfläche des Bildschirmfensters.
2. Applet: Eindimensionales Netz mit zweidimensionaler Eingabe
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/sauer-edg/applet.html
175
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.1.3.2.1.2 Kreisförmige Anordnung der Neuronenkette74
.
.
.
.
Abb.: Ring mit n Eingabeneuronen und m Ausgabeneuronen
1. Aufgabenstellung: Lösung eines TSP mit einem Kohonen-Netz
Bei zweidimensionaler Eingabe läßt sich jedem Neuron ein Punkt der Ebene
zuordnen. Die Verbindung ergibt eine geschlossene Kurve. Verbindet man alle
Punkte durch das Kohonen-Lernverfahren, so werden im Grenzwert benachbarte
Neuronen Gewichtsvektoren (d. h. Punkte der Ebene) besitzen, die topologisch nicht
weit auseinanderliegen. Daher ist die entsprechende Kurve eine geschlossene Kurve
minimaler Länge.
Das ermöglicht die Lösung des bekannten Travelling Salesman Problen (Problem
eines Handlungsreisenden, TSP). Ein Reisender soll k Städte anfahren und dabei
Punkte wählen, bei der der gesamte Reiseweg minmal ist. Gibt man k
Eingabevektoren bei n Neuronen vor (n >= k), so lernt das Netz eine geschlossene
Kurve (Städte).
Ausgangspunkt ist ein Kreis, dessen Punktkoordinaten als Startwerte eingegeben
werden. Die Lernschritte bewirken, daß der Kreis deformiert wird und sich immer
mehr den zu ermittelnden Reiserouten anpaßt.
Bei n Städten gibt es n! verschiedene Folgen von Städten. Es existieren jeweils 2  n
Folgen von Städten mit gleicher Weglänge, da ausgehend von einem Weg jede
Stadt als Startpunkt gewählt und der Weg in jeweils 2 verschiedene Richtungen
n!
zurückgelegt werden kann. Insgesamt gibt es daher
verschiedene geschlossene
2n
Routen. Das TSP-Problem ist daher durch einfaches Testen alle möglichen Routen
(Verfahren der vollständigen Enumeration) für eine große Anzahl von Städten
praktisch auf keiner Rechenanlage lösbar. In der Informatik werden Probleme mit
diesen Eigenschaften NP-vollständig genannt.
Mit Hilfe des von Kohonen definierten selbstorganisierenden Prozesses kann in
relativ kurzer Zeit eine gute Näherungslösung für dieses Problem gefunden werden.
2. Applet: Lösung TSP mit einem Kohonen-Netz
http://fbim.fh-regensburg.de/~saj39122/kiwei/nn.html
74
(vgl. PR28104.PAS)
176
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.1.3.2.2 Zweidimensionale Gitterstruktur
Abb.: Rechteckgitter (z.B. der Dimension 5 mal 3)
1. Aufgabenstellung
Jedem Neuron eines Gitters wird ein Punkt der Ebene zugeordnet: Wenn man zwei
Punkte, deren Neuronen im Gitter benachbart sind, miteinander verbindet, entsteht
ein Netz.
2. Applet: Zweidimensionales Neuronengitter
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/sauer-zdg/applet.html
177
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.1.4 Anwendungen
2.8.1.4.1 Zeichenerkennung mit Kohonen Feature Map
http://fbim.fh-regensburg.de/~saj39122/begrolu/nn1.html
2.8.1.4.1 Zahlenerkennung mit Kohonen Feature Map
http://fbim.fh-regensburg.de/~saj39122/NN/zimmermannLipfert/index.html
2.8.1.4.2 Spracherkennung
http://fbim.fh-regensburg.de/~saj39122/smp/index.html
178
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.2 Motorische Karten
2.8.2.1 Beschreibung
Bei den bisher betrachteten Netzen wurde jedem Eingabevektor ein lokal begrenztes
Feld im NN zugeordnet. Das entspricht bis zu einem gewissen Grad auch der
Arbeitsweise des Gehirns. Allerdings reicht die Stimulierung von Neuronengruppen
durch von außen eingeleitete Reize allein nicht aus, um die Lernfähigkeit eines
biologischen Individuums zu sichern. Die Eingabereize sollen auch Reaktionen
hervorrufen, die die Reize entsprechend beantworten.
Eingabe
Netz
Ausgabe
Abb. 2.8-3: Neuronales Netz mit Ein-, Ausgabe
Der unter 2.8.1 beschriebene Netztyp wird um Ausgaben erweitert. Alle Neuronen
des Netzes sind miteinander verbunden. Im Netz herrscht damit eine Rückkopplung.
Die Eingabevektoren wirken über die Gewichte wijein auf die Neuronen des Netzes.
Diese beeinflussen sich gegenseitig durch die Gewichte der Rückkopplung r ij. Falls
diese Gewichte auf weite Distanz hemmend, auf in der Nähe befindliche Neuronen
stimulierend wirken, sensibilisieren die Eingabevektoren Neuronengruppen statt
einzelner Neuronen. Den Ausgabewerten eintsprechen die Ausgabegewichte wijaus
179
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.2.2 Lernverfahren
Kinnebrock75 schägt zur Implementierung dieses Lernverfahrens folgende
Verfahrensweise vor:
(1) Wähle alle Gewichte wikein und wikaus aus


(2) Gib einen Eingabevektor i vor (sensorisches Signal). i wird aus einer
Wahrscheinlichkeitsverteilung gewählt.
2
(3) Suche das das Neuron („j“) für das  ( w ein
jk  i k ) minimal ist. „j" ist das
k
Erregungszentrum.
(4) Verbessere alle Gewichte wikein durch: wikein (t  1)  wijein (t )    rij  (ik  wikein (t )) mit
  0 . „j“ gibt das Erregungszentrum an.
(5) Vebessere alle Gewichte wikaus durch: wikaus (t  1)  wikaus (t )   'r 'ikij (ai  wijaus (t )) mit
' 0. „j“ gibt das das Erregungszentrum an.
(6) weiter bei (2)
Die Rückkopplungskoeffizienten rij und r'ij werden nach der Vorschrift


rij  exp( ( x i  x j ) 2 / 2  2 )
bzw.


r 'ij  exp( ( x i  x j ) 2 / 2   ' 2 )
berechnet.
 
xi , x j : Lagevektoren der sich beeinflussenden Vektoren
Sind Ein-, Ausgabewerte bekannt, dann ist das Lernverfahren ein Verfahren mit
Unterweisung.
Existiert lediglich eine Bewertungsfunktion, die für jede Ausgabe die Qualität der
Netzreaktion feststellen kann, dann läßt sich das Netz durch folgende Formel
beschreiben:
wijaus (t  1)  wijaus (t )   'r 'ij mit ' 0 und r'ij (gaußverteilte Zustandsgröße mit der
Varianz 1). Sind die so errechneten neuen Gewichte entsprechend der
Bewerungsfunktion besser, werden sie behalten, andernfalls vergessen (Lernen
ohne Unterweisung, Unsupervised Learning)
75
W. Kinnebrock: Neuronale Netze, ... , S. 93
180
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.2.3 Anwendungen
2.8.2.3.1 Kohonnen-Wippe
1. Ausgangssituation
Eine Wippe mit einem auf der linken Seite befestigten Störgewicht von 200 kg und
einem Wagen (Gewicht: 50 kg) auf der rechten Seite.
2. Ziel
Der Wagen soll auf der Wippe solange bewegt werden, bis der Gleichgewichtszustand erreicht wird.
3. Lösung
Zur Lösung dieses Problems wurde eine Kohonen Feature Map (motorische Karte)
gewählt. Dieser Netzwerktyp soll die physikalische Gesetzmäßigkeit des
"Hebelgesetzes" in Bezug auf die Wippe abbilden.
Folgende Einflußgrößen werden zum Trainieren des Netzes herangezogen:
Störgewichtentfernung und Wagengewicht. Wird einer dieser Parameter verändert,
so muß das Netz neu trainiert werden.
4. Trainieren des Netzes
Folgende Eingangsgrößen werden zum Trainieren des gewählten Netzwerktyps
herangezogen: Störgewichtsgröße, über das Hebelgesetz ermittelte Entfernung
zwischen Wagen und Unterstützungspunkt. Diese Eingangsgrößen werden über
Zufallszahlen ermittelt. Der Wertebereich der Störgewichtsgröße liegt zwischen -200
und +200 (Gewichtseinheiten), der Wertebereich der Entfernung des Wagens vom
Unterstützungspunkt liegt zwischen 0 und 5000 (Entfernungseinheiten). Die Funktion
des Lehrers übernimmt hierbei das Hebelgesetz.
5. Anleitung zur Bedienung des Applets
Durch Anklicken der Schaltfläche "Trainieren" wird das Kohonen-Netz mit den unter
"Lernschritte" und "Neuronen" angegebenen Werten berechnet.
Je mehr Lernschritte und Neuronen eingestellt werden, um so länger dauert die
Berechnung. Den momentanen Stand der vollzogenen Lernschritte kann man unter
der Grafik ablesen.
Sobald alle Lernschritte durchgeführt worden sind, ist die Schaltfläche "Simulieren"
aktiviert. Durch betätigen dieser Schaltfläche wird das Ergebnis in einer Animation
graphisch dargestellt. Durch betätigen der Schaltfläche "Reset" werden alle
ermittelten Werte zurück gesetzt.
Es wird empfohlen, unterschiedliche Anzahl von Lernschritten und Neuronen
einzusetzen, um die damit resultierenden Ergebnisse zu vergleichen .
6. Das Applet
http://fbim.fh-regensburg.de/~saj39122/Wilke/index.html
181
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.8.2.3.2 Auffangen eines Balls
1. Aufgabenstellung
Der Ball, dargestellt durch ein Symbol, befindet sich am oberen Bildschirmrand in der
Bildschirmmitte. Dieser Ball fällt unter Einfluß der Erdbeschleunigung nach unten,
wobei er gleichzeitig nach rechts oder links einen Stoß erhält. Es ensteht eine
parabelähnliche Flugbahn. Am unteren Bildschirmrand fährt ein Lastwagen (mit
einem Behälter, der Auffangvorrichtung), der sich zum Zeitpunkt des Starts vom Ball
auf der Position „pos“ befindet, mit der Geschwindigkeit v so, das er beim
Ankommen des Balls am unteren Ende den Ball auffängt. Der Wagen soll lernen,
seine Geschwindigkeit v so zu wählen, daß er den Ball auffängt.
Abb.
2. Physikalische Grundlagen der Aufgabenstellung:
Horizontale Bewegung des Balls: s 0  v0  t
v0: Geschwindigkeit mit der der Ball angestoßen wurde
s0: Stellung, Position des Balls zu Beginn des Experiments
Vertikale Bewegung des Balls: H - ½ g t2
H: Höhe des Balls
g: 9,81 m/s2
Der Behälter bewegt sich horizontal. Das kann so beschrieben werden: pos  v  t
182
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
pos: Anfangsposition des Lastwagens
v: Geschwindigkeit des Lastwagens
Gleichgewichtsbedingungen für das Auffangen des Balls durch den Lastwagen
s 0 v0  t  pos  v  t
Mit den Bildschirmabmessungen 0  x  630 (horizontal, von links nach rechts) und
0  y  199 (vertikal, von oben nach unten), den Zeitschritten t  0,1,2,3,...,14 erfolgt
ein Auffangen des Balls nach
pos  v  T  315  v0  T
Damit kann v in Abhängigkeit von v0 (Anfangsgeschwindigkeit des Balls) und pos
(Ausgangsposition des LKW) berechnet werden:
v
315
pos
pos
 v0 
 22.5  v0 
14
14
14
Schematischer Aufbau des Netzwerks. Das Netz besteht aus 2 Schichten:
ein
- WEIN ( wij besteht aus Zahlenwerten im Bereich von 0 .. 630 bzw. -22 bis 22)
aus
- WAUS ( wij
besteht aus Zahlenwerten im Bereich von 0 .. 630)
4. Das Applet
http://fbim.fh-regensburg.de/~saj39122/vhb/NN-Script/script/gen/Applets/nn-ball/nn_ball.html
183
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.9 RBF-Netze
2.9.1 Grundlagen
Aufbau

x
Eingabeschicht:
....
 
c1  x
Hidden-Schicht
1


cK  x
1
...
K
K
g11
Ausgabeschicht:

gK1

ck : Stützstellen
 k : Streuungsparameter

y
y1
-
yM
Das RBF-Netz besteht aus einer Eingabeschicht mit N Neuronen, einer verborgenen Schicht
mit K Neuronen und einer Ausgabeschichicht mit M Neuronen.
Eingabeschicht: jedes Neuron verteilt seine Wert an alle Neuronen der verborgenen Schicht.
verborgene Schicht: In der verborgenen Schicht wird in jedem Neuron der Abstand zwischen
der Eingabe und dem Zentrum c (mit Hilfe einer Norm) gebildet:
ck  xk . Danach wird dieser
Abstand z.b. durch eine Gauss-Kennlinie geschickt:
hk  hk  c k  x   exp( 
-
1
2
c k  x ) . Die Gauskennlinie ist abhängig von einem
2
2
Parameter  , der die Breite der Glocke angibt. Diese  muß für jedes Zentrum gewählt
werden. Die Gausglocke verursacht, dass das Neuron, wenn Zentrum und Muster nahe
beeinander liegen, sehr viel stärker als die lineare Kennlinie reagiert, wenn die Zentrum und
Muster weiter auseinander liegen, sehr viel schwächer.
Ausgabeschicht: In der Ausgabeschicht wird eine gewichtete Summe gebildet. Für das erste
Neuron der Ausgabeschicht wäre dies y1 
K
g
k 1
k1
 hk . Die Neuronen der Ausgabeschicht,
sowie auch alle anderen Neuronen haben keinen Bias.
Für das Lernen ergeben sich folgende einzustellende Werte:
1. die Zentren
2. die Breiten 
3. die Gewichte g
184
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Universelle Funktionsapproximator
RBF-Netze sind universelle Funktionsapproximatoren für Funktionen. Sie setzen
Funktionen als Überlagerung von Radialen zusammen
2.9.2 Einstellen der Gewichte, Anpassen bzw. Wahl der Zentren und
Breiten
2.9.2.1 Einstellen der Gewichte
Annahme: Es gibt schon die Zentren und Breiten der Gaußglocken. Es sind dann nur
noch die Gewichte gk an den Ausgabeneuronen zur Approximation der Zielfunktion
einzustellen. Das soll an einem Ausgabeneuron vollzogen werden. Die anderen
werden analog eingestellt. Die Anzahl der Neuronen ist K, die Anzahl der
Trainingsbeispiele ist P.
-
K > P: Dieser Fall ist uninteressant. Er ist auch sehr selten, da im Allg. mehr Trainingsmuster
vorliegen als Neuronen.
K = P: Für die Ausgabe des Netzes gibt es folgende P Gleichungen
p 1
K
y   g k hk (
p 1
k 1
p 2
K
y   g k hk (

x  ck )
p 2
k 1

x  ck )
....
pP
K
y   g k hk (
pP
k 1

x  ck )
In Matrixschreibweise ergibt dies:






Y  H  G bzw. G  H 1  D . Es wird vorausgesetzt, dass
-
die inverse Matrix existiert
K < P: Es gibt mehrere Möglichkeiten die Gewichte anzupassen:



Aufstellen der Gleichung: Y  H  G . Die Matrix kann nicht invertiert werden, da sie
nicht quadratisch ist. Es wird daher eine Pseudoinverse bestimmt, die Moore

PenrosePseudoinverse. Sie wird berechnet durch: H
Dimensionen



 ( H T  H ) 1  H T . In
1
( K  P  P  K )  ( K  P) . Die Moore-Penrose Pseudoinverse wird die


K K


K P




Fehlerquadrate minimieren. Also ergibt sich wieder: G  H  D
Hinweis: Die Berechnung mit der Moore-Penrose Pseudoinverse wird praktisch nicht
durchgeführt, da diese Matrizen sehr hohe Dimension haben, wenn es viele
Trainingsmuster gibt.
Das folgende Matlab-Skript
Pseudoinversen:
zeigt
die
185
Anwendung
der
Moore-Penrose-
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
% rbfexample1.m
clear all
xi=[-1 -0.5 1]';
n=length(xi);
d =[0.2 0.5 -0.5]';
x=[-3:0.02:3];
% construct the M matrix
% first find xi-xj
M0=abs(xi*ones(1,n)-ones(n,1)*xi');
% using Gaussian radial basis function
disp('with Gaussian radial basis function, ...')
M=(1/sqrt(2*pi))*exp(-0.5*M0.*M0)
w=pinv(M)*d
type=1; % Gaussian rbf
f0=zeros(size(x)); f=[];
for i=1:3,
para=[xi(i) 1];
f(i,:)=w(i)*kernel1d(type,para,x);
end
f0=sum(f);
figure(1), clf
plot(x,f(1,:),'k:',x,f(2,:),'b:',x,f(3,:),'r:',x,f0,'g.',xi,d,'r+')
title('F(x) using Gaussian rbfs')
axis([-3 3 -2 3])
Es wird eine Funktionsapproximation für drei Stützstellen ausgeführt:
186
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Der Gewichtsvektor kann auch durch Lernen an Beispielen bestimmt werden. Ein
Gradientenabstieg ist möglich. Es wird die  -Regel benutzt. Es gibt kein
Backpropagation, da nur in der Ausgabeschicht gelernt werden muß
2.9.2.2 Anpassen bzw. Wahl der Zentren und Breiten
Zentren
Die Stützstellen stellen Punkte dar durch die approximierende Funktion laufen sollte.
Dazu könnte jeder Trainingsvektor eine Stützstelle bestimmen. Jedoch können hier
statistische Ausreißer (z.B. Messfehler) oder große Datenmengen zu Fehlern führen.
Daher ist man interessiert, dass verfügbare Datenmaterial zu komprimieren. Dazu
können Cluster gebildet werden, die das verfügbare Meterial komprimieren.
Breiten
Es ist darauf zu achten, dass durch die Kombination mit der Streuung der
Musterraum vollständig abgedeckt wird. Praktisch kann das so aussehen, dass man
zur Bestimmung der Steung für eine Stützstelle zunächst an den k nächsten
Nachbarn einen gemittelten Vektor festlegt. Aus dem Abstand dieses Vektors zur
Stützstelle kann man die Steuung ableiten.
d
Für die Berechnung wurden auch folgende Heuristiken herangezogen:  
oder
2K
1
  d
3
187
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.10 ART
2.10.1 Einführung
2.10.2 Struktur
2.10.3 Lernen im ART-Netzwerk
2.10.4 Leistungen und Grenzen vom ART
188
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.11 Counter Propagation
2.11.1 Die Netzstruktur
1. Beschreibung
Das Netzwerk76 besteht aus 3 Schichten: Eingabeschicht, Kohonenschicht,
"Grossberg-Outstarschicht".
..............
Eingabeschicht
..............
Kohonenschicht
Grossberg
-Outstarschicht
..............
Abb.: 2.5-1: Topologie des Netzes "Counter Propagation"
Der Informationsfluß läuft von der Eingabeschicht über die Kohonenschicht zur
"Grossberg-Outstarschicht".
2. Eingabeschicht
Das Netzwerk ermöglicht binäre und reellwertige Eingaben (und Ausgaben). Es ist
sinnvoll, die Eingabevektoren bei diesem Netzwerktyp zu normieren. Jedes Element
der Kohonenschicht bekommt einen Input von jedem Element der Eingabeschicht.
3. Kohonenschicht
Jedes Kohonen-Element berechnet den aufsummierten, mit den Gewichten
multiplizierten Input durch:
n
neti   wij  o j
j 1
bzw.
76
Mitte der 80er Jahre von R. Nielsen entwickelt (Kombination der Ansätze von T. Kohonen und S. Grossberg)
189
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen


neti  wi  x

wi : Gewichtsvektor des i-ten Kohonen-Elements (i-ter Zeilenvektor)77

x : Eingabevektor der Kohonenschicht.
Das Element mit dem größten neti erhält die Ausgabe oi = 1, die anderen Elemente
haben die Ausgabe oi = 078.
Im zweidimensionalen Fall ist das Skalarprodukt zwischen einem normalisierten
Gewichts- und Eingabevektor gleich dem Cosinus des Winkels  zwischen Eingabeund Gewichtsvektor: neti  cos
Je Kleiner der Winkel zwischen Gewichts- und Eingabevektor ist, d.h. je dichter die
beiden Vektoren beieinander liegen, umso größer ist neti . Zeigen die beiden
Vektoren in die gleiche Richtung, dann ist neti  1. Das Gewicht, dessen
Gewichtsvektor die größte Ähnlichkeit zum Eingabevektor zeigt, hat die größte
Aktivität.
Legt man einen Eingabevektor an die Kohonenschicht an, so wird die Eingabe des
Elements zu 1, dessen Gewichtsvektor die größte Ähnlichkeit mit dem Eingabevektor
hat. Betrachtet man jeden einzelnen Gewichtsvektor als Klasse oder Kategorie, so
findet eine Klassifizierung des angelegten Eingabevektors in die für ihn am besten
passende Kategorie statt.
4. Grossberg-Outstarschicht
Jedes Outstar-Element i berechnet die gewichtete Summe seiner Eingaben:
neti   wij  o j und oi  neti
Da in der Kohonen-Schicht nur ein Element aktiv und die Ausgabe aller anderen
Elemente null ist, entspricht die Ausgabe jedes Outstar-Elements i dem Gewicht zu
dem aktiven Kohonen-Element k.
oi  wik



Für den Ausgabevektor o gilt: o  w k

w k ist die Spalte des aktiven Kohonen-Elements k in der Gewichtsmatrix der
Outstarschicht.
77
Die Zeilenvektoren der Gewichtsmatrix sind normalisert
Die Kohonen-Schicht ist eine sog. "Winner take all"-Schicht. Bei gegebener eingabe wird genau ein element
aktiv.
78
190
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2.11.2 Lernvorgänge in den Schichten
1. Lernen in der Kohonenschicht
Die Kohonenschicht ist selbstorganisierend und umfaßt einen Algorithmus für nicht
überwachtes, entdeckendes Lernen. Nur das Element darf seine Gewichte
ausrichten, das die größte Aktivität hat. Die Lernregel für dieses Element i ist:
wij ( t  1)  wij ( t )    ( o j  wij ( t ))
bzw. (in Vektorschreibweise)




wi ( t  1)  wi ( t )    ( x  wi ( t ))
oj: Ausgabe des Eingabeelements
 : Lernrate. Sie besitzt einen Startwert kleiner eins (z.B. 0.7) und wird im Laufe des
Trainings reduziert.
2. Trainieren in der Grossbergschicht
Sie wird durch überwachtes Lernen trainiert. Es gilt
wij ( t  1)  wij ( t )    ( zi  wij ( t ))  o j
zi: gewünschte Ausgabe des i-ten Outstar-Elements
oj: Ausgabe des j-ten Kohonen-Elements
Die Lernrate  sollte auf einen sehr kleinen Wert (z.B. 0.1) gesetzt werden. Sie wird
dann während des fortschreitenden Lernens weiter reduziert.
Die Grossbergschicht erzeugt zu jeder Klasse (d.h. zu jedem Kohonen-Element) eine
sinnvolle Ausgabe79.
79
durchschnittliche Repräsentation der Zielausgabe zu der von einem Kohonen-Element dargestellten
Ergebnismenge
191
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3. Fuzzy-Systeme
3.1 Fuzzy-Logik
3.1.1 Einführung in die Denkweise
3.1.1.1 Unscharfe Mengen (Fuzzy-Sets)
Fuzzy-Systeme kodieren direkt strukturiertes Wissen (Regeln) in numerischer Form.
Die "Fuzzy-Set-Theorie" wurde 1965 von Prof. Zadeh (Uni Berkeley, Kalifornien)
eingeführt. Prof. Zadeh stellte fest: "Herkömmliche (Computer-) Logik kennt keine
Manipulation von Daten, die vage oder subjektive Konzepte repräsentieren. (z.B. Es
ist ziemlich kalt, eine schöne Frau). Die Fuzzy-Set-Theorie geht von der Annahme
aus, daß alle Dinge nur zu einem gewissen Grad zutreffen und reduziert die
herkömmliche Logik auf einen Sonderfall. Gerade der Mangel an Präzision
ermöglicht: Das Treffen von Entscheidungen, selbst in Situationen, in denen
unvollständige oder teilweise widersprüchliche Informationen vorliegen.
Bsp.: Darstellung der Temperatur durch eine Zugehörigkeitsfunktion  für eine
scharfe Menge.
 (T )
1.0
T
10
20
30
40
Abb. 3.1-1: Darstellung der Temperatur als scharfe Menge
Die Zugehörigkeitsfunktion zur scharfen Menge ist durch zugehörig ("1") oder nicht
zugehörig ("0") bestimmt. Sind Werte der Zugehörigkeitsfunktion sind nicht nur Null
oder Eins sondern beliebige Werte zwischen 0 und 1, dann spricht man von einer
unscharfen Menge (Fuzzy Set).
Bsp.: Darstellung der Temperatur durch eine Zugehörigkeitsfunktion  für eine
unscharfe Menge.
192
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
 (T )
1.0
T
10
20
30
40
Abb. 3.1-2: Darstellung der Temperatur als unscharfe Menge
Ein Fuzzy-Set wird durch die Zugehörigkeitsfunktion immer eindeutig dargestellt.
Eine Zugehörigkeitsfunktion kann beliebige Werte zwischen 0 und 1 annehmen.
Dadurch werden beliebig feine Abstufungen zwischen "gehört dazu" und "gehört
definitiv nicht dazu" vorgenommen
3.1.1.2 Funktionstyp
Hinsichtlich des Funktionstyps von Zugehörigkeitsfunktionen haben sich einige
Standardformen herausgbildet: Trapeze und Dreiecke werden am häufigsten
eingesetzt. Für derartige Fuzzy-Sets spricht die geringe Anzahl von Parametern (4
bzw. 3 Punkte sind festzulegen) und der geringe Rechenaufwand (Vorteil bei
zeitkritischen Anwendungen). Daneben gibt es Fuzzy-Sets mit S-kurvenförmigen
Flanken oder in Form der Normalverteilungsfunktion (Einsatz bei Datenanalyse und
Mustererkennung).
Mathematisch läßt sich ein Fuzzy-Set beschreiben als eine geordnete Menge von
Paaren:
A = {(x,  A ( x) | x  X }
 A ( x) : Zugehörigkeitsfunktion (Untermenge der reellen Zahlen)
3.1.1.3 Operatoren auf Fuzzy-Mengen
Informationen werden gewöhnlich durch "UND" und "ODER" miteinander verknüpft.
Die Verknüpfung zweier unscharfer Informationen durch UND und ODER müssen
auch eine Ableitung auf Fuzzy-Mengen besitzen, wenn eine Fuzzy-Modellierung
einen Sinn haben soll.
Analog zu den Operatoren der Booleschen Algebra UND, ODER und NICHT hat die
"Fuzzy Logik" neue Operatoren entwickelt:
Wahrheitsgrad 2er Aussagen, die durch ODER verknüpft sind
(Maximumoperator für die Vereinigung zweier Fuzzy-Sets C  A  B )
C ( x) =max{  A ( X ) ,  B ( X ) } x  X
193
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Wahrheitsgrad 2er Aussagen, die durch UND verknüpft sind
(Minimumoperator für den Durchschnitt zweier Fuzzy-Sets C  A  B )
C ( x) =min{  A ( X ) ,  B ( X ) } x  X
Wahrheitsgrad der Negation
(Komplement C eines Fuzzy-Set A)
C ( x) =1-  A ( X )
x X
Bsp.: Die folgende Darstellung beschreibt die Fuzzy Sets "Warm" bzw. "Heiss":
 (T )
1.0
warm
heiss
0.5
Temperatur [°C]
10
20
30
40
Abb.: 3.1-3 Darstellung der Fuzzy Sets „Warm“ bzw. „Heiss“
a) Zeichne in die vorstehende Darstellung das Fuzzy-Set "heiss und warm" ein.
b) Zeichne in die vorstehende Darstellung das "Fuzzy-Set "heiss oder warm" ein.
c) Zeichne in die vorstehende Darstellung das Ergebnis der Komplementbildung aus
dem Fuzzy-Set "heiss" (Resultat Fuzzy-Set "nicht heiss") ein.
3.1.1.4 Linguistische Variable
Definition: Linguistische Variable sind Variable sprachlicher Art, die unscharfe
Mengen als Werte besitzen. Werte von linguistischen Variablen heißen auch
linguistische Terme (auch uinscharfe Kategorien).
Derartige Variable umfassen Werte, die durch Wörter wie "heiß" oder "kalt"
repräsentiert werden. Die einzelnen Werte einer linguistischen Variable werden
durch Fuzzy-Sets ausgedrückt:
Bsp.: Die linguistische Variable Raumtemperatur
Die Raumtemperatur kann als linguistische Variable mit den Termen kalt, warm und
heiß aufgefaßt werden. Jeder Term wird als Fuzzy-Set modelliert:
194
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Zugehörigkeitsfunktion
Kalt
1.0
warm
heiss
0.8
0.6
0.4
0.2
10
20
30
Temperatur (°C)
Abb. 3.1-4: Darstellung der linguistischen Variablen Raumtemperatur
3.1.1.5 Fuzzy-Regeln
Zur Formulierung von menschlichem Erfahrungswissen werden Fuzzy-Regeln
verwendet:
Bsp.: Regeln beim Autofahren
- Wenn der Abstand zum vorderen Auto klein ist und die Geschwindigkeit groß, dann
bremse mit großer Kraft
- Wenn der Abstand zum vorderen Auto im Mittel liegt ("mittel" ist) und die
Geschwindigkeit groß, dann bremse mit mittlerer Kraft.
Die linguistischen Variablen Abstand (D), Geschwindigkeit (V) und Bremskraft (F)
lassen sich so darstellen:
 (T )
50
100
Abstand [m]
50
100
Geschwindigkeit [km/h]
50
100
Bremskraft [%]
Abb. 3.1-5: Darstellung der Regeln, Abstand, Bremskraft, Geschwindigkeit
Für jede linguistische Variable wurden 3 dreieckige Fuzzy-Sets (klein (PS), mittel
(PM) und groß (PL) ) gewählt. Die beiden Regeln sind:
Wenn (D = PS) und (V = PL), dann (F = PL)
Wenn (D = PM) und (V = PL), dann F = PM)
Regel 1: R1
Regel 2: R2
Abstand
PS
PM
Geschwindigkeit Bremskraft
PL
PL
PL
PM
Regeln können in eine Regeltabelle folgender Gestalt eingetragen werden:
195
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Abstand
NB NM NS ZR
NB
NM
NS
ZR
PS
PM
PB
PS
PM PB
PL
PM
Geschwindigkeit
Ein unscharfe Variable kann offensichtlich eine Reihe unscharfer Werte annehmen:
NB (Negative Big) bzw. NL (Negative Large)
NM (Negative Medium)
NS (Negative Small)
ZE (Zeroe)
PS (Positive Small)
PM (Positive Medium)
PB (Positive Big) bzw. PL (Positive Large)
Die Regeltabelle zeigt: Fuzzy-Systeme speichern und verarbeiten unscharfe Regeln
parallel. Fuzzy-Systeme assoziieren Ausgangs-Fuzzy-Sets mit Eingangs-Fuzzy-Sets
und verhalten sich wie "quasi" assoziative Speicher.
3.1.1.6 Unscharfe Relationen
Neben unscharfen Mengen sind unscharfe Relationen ein wichtiges Teilgebiet der
Fuzzy-Set-Theorie. Unscharfe Relationen bilden die theoretische Basis für die
Realisierung unscharfer Regler und Expertensystemen.
Eine unscharfe (binäre) Relation über dem Produktraum X  Y ist definiert durch
R={ (( x, y),  R ( x, y) | ( x , y )  X  Y }
Falls X und Y diskrete Mengen sind, dann können X und Y durch Matrizen definiert
werden, z.B.:
X = {grün, gelb, rot} beschreibt die Farbe einer Frucht
Y = {unreif, halbreif, reif} beschreibt den Reifegrad einer Frucht.
Die Paare, die zueinander passen, sind dann
R1={(grün,unreif),(gelb,halbreif),(rot,reif)}
und können in einer Tabelle zusammengefaßt werden:
X \ Y
grün
gelb
unreif
1
0
halbreif
0
1
reif
0
0
196
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
rot
0
0
1
Die in der Tabelle zusammengestellten Paare entsprechen den folgenden (auf
Erfahrung beruhenden) Regeln:
WENN eine Frucht grün ist DANN ist sie unreif
WENN eine Frucht gelb ist DANN ist sie halbreif
WENN eine Frucht rot ist DANN ist sie reif
Daraus folgt: Relationen eignen sich zur Modellierung von WENN ... DANN ...Regeln.
Da die Relationsmatrix nur Nullen und Einsen enthält, handelt es sich noch nicht um
eine wirkliche Fuzzy-Relation. Man weiß aber, daß diese Erfahrungsregeln nur
ungefähr stimmen. Eine Fuzzy-Relation R2 ist dann:
X \ Y
grün
gelb
rot
unreif
1
0.3
0
halbreif
0.5
1
0.2
reif
0
0.3
1
Fuzzy-Mengen können auf einfachen Grundmengen (G 1, G2, ..) durch Operatoren,
z.B. den min-Operator für die UND-Verknüpfung, zu Fuzzy-Relationen über die
Kreuzproduktmenge der zugrundliegenden Grundmengen verbunden werden.
1   2  1T   2
Die vorliegende Formel unterscheidet sich vom normalen Matrizenprodukt dadurch,
daß bei der Operation "Zeile mal Spalte" die Produktbildung durch den MinimumOperator und die Addition der Matrizen durch den Maximum-Operator ersetzt wird.
Bsp.: Junger UND großer Mann
Gegeben sind die Fuzzy-Mengen für "Junger Mann" und "Großer Mann".
197
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2
1
15
20
25
30
35
Alter
170
180
Groesse [cm]
Abb. 3.1-6: Die Fuzzy-Mengen „junger“ bzw. „großer“ Mann
Ein "junger" UND "großer" Mann ist eine Fuzzy-Relation auf den beiden
Grundmengen "Alter" und "Größe":
 R ( Alter , Größe)  min (1 ( Alter ), 2 (Größe))
Falls die Grundmengen auf 5 äquidistante Stützstellen beschränkt werden, ergibt
sich folgende Tabellendarstellung der Relationsmatrix:
Alter\Größe
15
20
25
30
35
170
0
0
0
0
0
175
0
0.5
0.5
0.5
0
180
0
0.5
1
0.5
0
185
0
0.5
1
0.5
0
190
0
0.5
1
0.5
0
Eine Relation "Junger ODER Großer Mann" kann auf analoge Weise gebildet
werden, indem der min-Operator durch den max-Operator ersetzt wird.
Der Ausdruck  R ( x, y)  min (1 ( x), 2 ( y)) heißt Kreuzprodukt oder cartesisches
Produkt der Fuzzy-Mengen.
Auch Fuzzy-Relationen mit derselben Produktmenge lassen sich miteinander
verknüpfen:
Falls R1 und R2 zweistellige Fuzzy-Relationen sind, dann gilt für den Durchschnitt
von R1 und R2 (UND-Verknüpfung)
 R  R ( x , y )  min (  R ( x , y ),  R ( x , y ))
1
2
1
2
und für die Vereinigung (ODER-Verknüpfung)
 R  R ( x , y )  max (  R ( x , y ),  R ( x , y ))
1
2
1
2
198
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.2 Verarbeitung in Fuzzy-Systemen: Fuzzy-Inferenz
Fuzzy-Inferenz bedeutet: Fuzzy-logisches Schließen auf unscharfen Informationen.
Eine Inferenz besteht aus einer oder mehreren Regeln (Implikationen), einem
Faktum (aktueller Zustand, aktuelles Ereignis) und einer Schlußfolgerung. Sie ersetzt
das Faktum unter Berücksichtigung der Implikation(en) durch ein neues Faktum.
3.1.2.1 Ein einführendes Beispiel
Es umfaßt die folgenden Regeln:
Regel (1)
WENN Temperatur = sehr hoch ODER Kammerdruck = übernormal DANN Ventil gedrosselt
Regel (2)
WENN Temperatur = hoch UND Kammerdruck = normal DANN Ventil = halb offen.
Die Abarbeitung linguistischer Regeln zeigen die folgende Arbeitsschritte, die zur
Beantwortung der Frage " Wie ist die erforderliche Stellung eines Ventils bei einer
Temperatur von 910°C und einem Kammerdruck von 40.7 bar?" anfallen:
1. Fuzzyfizierung
Darunter versteht man: Die linguistische Interpretation technischer Größen.
Die technische Größe "Temperatur" wird so interpretiert:
Zugehörigkeitsfunktion
Niedrig
1.0
mittel
hoch
sehr hoch
0.8
0.6
0.4
0.2
400
500
600
700
800
Abb. 3.1-7: Temperatur in der Kammer
Im vorliegenden Fall gilt bspw. für die Tempeartur 910°C:
sehr hoch
hoch
mittel
niedrig
0.8
0.3
0.0
0.0
Die technische Größe "Druck" wird so interpretiert:
199
900
Temperatur (°C)
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Zugehörigkeitsfunktion
Unter normal
1.0
normal
übernormal
0.8
0.6
0.4
0.2
39
40
41
Druck (bar)
Abb. 3.1-8: Druck in der Kammer
Im vorliegenden Fall gilt für den Druck 40.5 bar:
unter normal
normal
über normal
0.0
0.5
0.5
2. Berechnung der Wahrscheinlichkeiten für Vorbedingungen zu Regeln
Die Vorbedingungen zu Regel (1) bzw. Regel(2) des einführenden Beispiels lassen
sich berechnen:
Regel (1): max(0.8, 0.3) = 0.8
Regel (2): min(0.3, 0.5) = 0.3
3. Zurückführung der Resultate der Regeln
Auch für die Stellung des Ventils wird eine linguistische Variable eingeführt:
200
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Zugehörigkeitsfunktion
gedrosselt
1.0
halb offen
mittel
offen
0.8
0.6
0.4
0.2
4
8
12
16
Durchfluß
Abb. 3.1-9: Ventil
Die linguistische Variable Ventil beschreibt die einem Brennofen zuzuführende
Menge an Brennstoffen (als Reaktion auf den in einer Brennkammer herrschenden
Druck und Temperatur).
Zur Zurückführung der Resultate der Regeln auf deren Definition gibt es in der
Fuzzy-Logik zwei alternative Methoden:
- die Max-Min-Inferenz
- die Max-Prod-Inferenz
3.1 Max-Min-Inferenz
Die unscharfe Menge der Terme der linguistischen Variablen "Ventil" werden jeweils
auf den Wahrheitsgrad der Vorbedingung begrenzt (Minimum). Die so erhaltenen
Mengen werden zu einer einzigen zusammengefaßt (Maximum). Diese unscharfe
Menge ist das Resultat der Inferenz.
Zugehörigkeitsfunktion
gedrosselt
1.0
halb offen
mittel
offen
0.8
0.6
0.4
0.2
4
8
12
Abb. 3.1-10: Max-Min-Inferenz
201
16
Durchfluß
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2 Max-Prod-Inferenz
Es wird ein Produkt aus unscharfer Menge des Terms der Schlußfolgerung und des
Wahrheitsgrads der Vorbedingung gebildet.
Zugehörigkeitsfunktion
gedrosselt
1.0
halb offen
mittel
offen
0.8
0.6
0.4
0.2
4
8
12
16
Durchfluß
Abb. 3.1-11: Max-Prod-Inferenz
Als Ergebnis erhält man für die Stellung des Methanventils der beiden Methoden
eine unscharfe Menge.
4. Defuzzifizierung
Es gibt hierfür verschiedene Methoden. Am häufigsten wird benutzt: Berechnung der
technischen Größe aus dem Flächenschwerpunkt der unscharfen Menge.
Zugehörigkeitsfunktion
gedrosselt
1.0
halb offen
mittel
offen
0.8
0.6
0.4
0.2
4
8
12
16
Durchfluß [m 3/h]
Abb. 3.1-12: Ermitteln des Flächenschwerpunkts
Im angegebenen Beispiel ergibt sich die Stellung des Ventils zu 2.7 m 3/h
202
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.2.2 Fuzzy-Inferenzschema
Eine Fuzzy-Inferenz ist eine Verarbeitungsvorschrift für WENN.. DANN.. -Regeln
bzw, für ganze Gruppen von Regeln für unscharfe Aussagen. In der Fuzzy-Linguistik
kann zur Modellierung von WENN.. DANN.. -Regeln der min-Operator benutzt
werden.
1. Bsp.: Erhitzen von Wasser
Regel: WENN Temperatur T = niedrig DANN Wärmezufuhr hoch
Zugehörigkeitsfunktion für die linguistische Terme Tempeartur und Wärmezufuhr:
Zugehörigkeitsfunktion
1.0
0.8
0.6
0.4
0.2
10
20
30
40
50
Temperatur T [°C]
60
70
80
90
100
W [%]
Relationsmatrix (ermittelt über das Kreuzprodukt):  R (T ,W)  min (T (T ), W (W))
W
T
10
20
30
40
50
60
70
80
90
100
0
0
0
0
0
0
0.5
0.5
0.5
0
0
0.5
1
0.5
0
0
0.5
0.5
0.5
0
0
0
0
0
0
Die gebräuchlichste Art einer Inferenz80 ist die Max-Min-Komposition. So ergibt sich
bspw. für das aktuelle Faktum T = 20°C das folgende Inferenzergebnis:
W hoch' (W )   R ( T  20 C ,W )  min ( Tniedrig( 20 C ), W hoch (W ))
 R ist die über das Kreuzprodukt von Prämissen- und Konklusions-Fuzzy-Mengen
gewonnene Fuzzy-Relation der Regel.
Aus der Relationsmatrix kann abgelesen werden: Whoch' (W)  (0, 0.5, 0.5, 0.5, 0)
Grafisch kann der Inferenzvorgang so dargestellt werden:
80
Eine Inferenz ist eine Verarbeitungsvorschrift für WENN... DANN... Regeln unter Berücksichtigung eines
aktuellen Faktums (Ereignisses). Sie hat eine Schlußfolgerung als Ergebnis
203
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Zugehörigkeitsfunktion
1.0
0.8
0.6
0.4
0.2
10
20
30
40
50
Temperatur T [°C]
60
70
80
90
100
W [%]
Abb. 3.1-16: Darstellung des Inferenzvorgangs
Die Eingangsgröße ist ein scharfer Temperaturwert von 20°C und somit als Singleton
Whoch' auf der Grundmenge G1= {10,20,30,40,50} der Temperatur darstellbar. Das
Inferenzergebnis erhält man dann auch über die Relationsmatrix durch:
 Whoch'
 0 0 0 0 0


 0 0.5 0.5 0.5 0
 0 1 0 0 0   0 0.5 1 0.5 0  0 0.5 0.5 0.5 0


 0 0.5 0.5 0.5 0


 0 0 0 0 0
2. Verarbeitungsvorschrift zur Ermittlung der Fuzzy-Ergebnismenge
Das Max-Min-Inferenzschema liefert bei einer Regel WENN A DANN B mit dem
linguistischen Term  A ( x) in der Prämisse und dem Term  B ( y ) in der Konklusion
bei Vorliegen einer scharfen Eingangsgröße x' eine Ergebnis-Fuzzy-Menge  B' ( y) .
Diese kann in der zu x' zugehörgen Zeile  R ( x', y) der über das Kreuzprodukt
gebildeten Relationsmatrix der Regel unmittelbar abgelesen oder grafisch ermittelt
werden, indem man die Fuzzy-Menge  B ( y ) der Konklusion in der Höhe des
Erfüllungsgrads  A ( x ') abschneidet.
3. Verhalten bei mehreren Regeln
Für jede weitere Regel kommt eine entsprechende Relationsmatrix hinzu. Die
Regeln innerhalb des Systems von Regeln sind i.a. ODER verknüpft. Die
Relationsmatrizen werden daher über den "Max"-Operator verbunden. Ergebnis ist
eine einzige Relationsmatrix, die alle Regeln enthält und wie im Falle einer Regel
ausgewertet werden kann. Alternativ dazu kann man die Regeln zunächst getrennt
voneinander auswerten und im Abschluß daran deren Ergebnis-Fuzzy-Mengen mit
dem Max-Operator überlagern.
204
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Bsp.: Erhitzen von Wasser
4.1 Regelbasis
R1: WENN T = sehr_niedrig DANN W = sehr_hoch
R2: WENN T = niedrig
DANN W = hoch
R3: WENN T = mittel
DANN W = mittel
R4: WENNT = hoch
DANN W = niedrig
R5: WENN T = sehr_hoch DANN W = sehr_niedrig
4.2 Linguistische Variable für Temperatur T und Wärmezufuhr W
Zugehörigkeitsgrad  T
Sehr niedrig
1.0
niedrig
mittel
hoch
sehr hoch
0.8
0.6
0.4
0.2
0
10
Zugehörigkeitsgrad
20
30
40
50
60
70
80
90
100 Temperatur (°C)
W
Sehr niedrig
niedrig
mittel
hoch
sehr hoch
1.0
0.8
0.6
0.4
0.2
0
10
20
30
40
50
60
70
80
90
100
W(%)
Abb. 3.1-18: Linguistische Terme für Temperatur und Wärmezufuhr
4.3 Ziel: Ermitteln einer geeigneten Wärmezufur für einen scharfen Temperaturwert
T = 45°C.
4.4 Lösungsschema:
4.4.1 Fuzzifizierung der scharfen Eingangsgröße
205
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
  Tsehr _ niedrig (T)  0 

 

  Tniedrig (T)   0.25
  Tmittel (T)    0.75

 

  Thoch (T)   0 


 
 Tsehr _ hoch (T)   0 
4.4.2 Ermitteln der aktiven Regeln
Eine Überprüfung der Regelbasis zeigt, daß lediglich die Regeln R 2 und R3 aktiv
sind, d.h. einen Erfüllungsgrad größer als Null besitzen:
- Der WENN-Teil von R2 ist zu  Tniedrig ( T )  0. 25 erfüllt
- Der WENN-Teil von R3 ist zu Tmittel (T )  0. 75 erfüllt
bzw.
- R2 besitzt den Erfüllungsgrad H2=0.25
- R3 besitzt den Erfüllungsgrad H3=0.75
4.4.3 Ermittlung der einzeln Ausgangs-Fuzzy-Mengen
Die Anwendung jeder aktiven Regel liefert auf der Basis des Inferenzschemas die
resultierende Ausgangs-Fuzzy-Menge, indem man den Erfüllungsgrad der Regel auf
die jeweilige Fuzzy-Menge in der Schlußfolgerung überträgt. Dazu wird das Minimum
von Erfüllungsgrad und Ausgangs-Fuzzy-Menge min ( Hi , Wi (W )) gebildet, d.h. Die
Ausgangs-Fuzzy-Menge in der Höhe Hi abgeschnitten.
T
Zugehörigkeitsgrad
niedrig
1.0
W
Zugehörigkeitsgrad
1.0
hoch
H2
0.0
0.0
10
20
30
40
50
60
70
80
90
T
Zugehörigkeitsgrad
10
100
T(°C)

Zugehörigkeitsgrad
mittel
1.0
30
20
40
60
70
80
90
100
W(%)
60
70
80
90
100
W(%)
W
1.0
0.0
50
mittel
0.0
10
20
30
40
50
60
70
80
90
10
100
T(°C)
Abb. 3.1-19: Auswertung der Regeln
206
20
30
40
50
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4.4.4 Überlagerung der einzelnen Ausgangs-Fuzzy-Mengen
Da die einzelnen Regeln implizit ODER-Verknüpfungen sind, müssen die
zugehörigen Ergebnis-Fuzzy-Mengen über den Max-Operator zur resultierenden
Ausgangs-Fuzzy-Menge W res (W )  max (min ( Hi , Wi (W ))) vereinigt werden.
Zugehörigkeitsgrad
W
Sehr niedrig
niedrig
mittel
hoch
sehr hoch
1.0
0.8
0.6
0.4
0.2
0
10
20
30
40
50
60
70
80
90
100
W(%)
Abb. 3.1-20: Überlagerung der Fuzzy-Mengen
4.4.5 Defuzzifizierung
Aus der resultierenden Ergebnis-Fuzzy-Menge muß in den meisten Fällen ein
scharfer Ausgangswert bestimmt werden.
207
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.2.3 Anwendungen
3.1.2.3.1 Anwendungsbeispiel: Berg- und Talfahrt eines Fahrzeugs81.
1. Problem
Bei der Berg- und Talfahrt eines Fahrzeugs sind verschiedene Kräfte auszugleichen.
Durch die Schwerkraft wird das Fahrzeug bestrebt sein, den Berg hinabzurollen.
Zusätzlich können Störkräfte (Rauschkomponenten) und Handsteuerkräfte vom
Bediener (über Cursor-Tasten simuliert) vorkommen.
Hangabtriebskraft
Rauschkraft
Bewegungssimulation
v
Handsteuerkraft
des Fuzzy-Mobils
x
Fuzzy-Kraft
Fuzzy-Steuerung
Abb. 3.1-21: Block-Diagramm der Fuzzy-Steuerung
2. Lösung
Zur Lösung des Problems wird ein Prozeß simuliert, der als Meßwerte die aktuelle


Geschwindigkeit v und Position x liefert und der durch eine Anzahl von
Kraftkomponenten beeinflußt wird, die als Stör- und Steuergrößen wirken. das
Simulationsprogramm muß Bewegungssimulation und Fuzzy-Steuerung realisieren82.
3. Physikalisches Grundwissen:

dv
v
(1) K  m  b  m 
 m
dt
t

Falls die Zeitdifferenz klein genug gewählt wird und die Kraft sich im betrachteten
Zeitraum nicht oder nur unwesentlich ändert, kann man die Differentiale durch
Differenzen ersetzen und die Geschwindigkeit zum Zeitpunkt t berechnen.




K (t )
 t  v ( t )  k R
(2) v ( t  1)  v ( t ) 
m
In (2) ist noch eine geschwindigkeitsabhängige Kraftkomponente mit dem
Reibungskoeffizienten kR eingeführt.
81
vgl.: mc, März 1991: Das Fuzzy-Mobil
Auch in der Praxis wird so verfahren: Zuerst möglichst exakte Prozeßsimulation, danach Kopplung mit FuzzySteuerung und Test
82
208
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen

Die Geschwindigkeit ist die 1. Ableitung des Weges x nach der Zeit. Man kann die
neue Position zum Zeitpunkt t+1 aus der Position zum Zeitpunkt t berechnen:



(3) x ( t  1)  x ( t )  v ( t )  t
Zur Berechnung der Bewegung fehlt in (2) noch die Kraft. Sie setzt sich zusammen



aus der Hangabtriebskraft K H , Rauschkraft K R , Handsteuerkraft KS und der Fuzzy
Steuerkraft K F :





(4) K ( t )  K H (t )  K R (t )  KS (t )  K F (t )
Die Handsteuerkraft wird durch Tastenbetätigung festgelegt, die Rauschkraft wird als
Zufallswert zwischen 0 und einer definierten Maximalkraft bestimmt.

Geländefunktion P(x)

KG

KH
Abb. 3.1-22: Kräfte in Abhängigkeit vom Bodenprofil


In Abhängigkeit vom Winkel des Gefälles zerlegt sich die Gewichtskraft K G in K H

(läuft parallel zum Hintergrund) und eine zu K H rechtwinklige Komponente. Die
Bewegung ist im wesentlichen eindimensional. Auf die Vektordarstellung kann daher
verzichtet werden. Unter Anwendnung einiger geometrischer Beziehungen ergibt
sich folgende Gleichung:


(5) K H ( x )   K G  sin ( x )
Der Winkel hängt vom Bodenprofil ab. Für die Berechnung des Winkels gilt die
Gleichung:
(6)  ( x )  arctan( P ' ( x ))
Ersetzt man  in Gleichung (5) durch Gleichung (6) erhält man:
(7)  KG 
P' ( x)
1  ( P ' ( x )) 2
Mit Gleichung (7) wird die Hangabtriebskraft berechnet und mit mit den
verbleibenden Kräften zur Gesamtkraft überlagert. Mit dieser Kraft und Gleichung (2)
wird die Änderung der Geschwindigkeit berechnet. Über Gleichung (3) wird die neue
Position ermittelt.
209
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Regeln
Das Fuzzy-System erhält vom Simulationsmodell die Daten der momentanen
Geschwindigkeit v und der Position x. Das Steuersystem hat die Zielvorgabe, das
Fahrzeug bei der Position x=0 mit der Geschwingkeit v=0 zu halten. Sieben FuzzyRegeln83 mit den Ausgangspunkten Betrag und Richtung der Geschwindigkeit und
der Position sollen eine linguistische Verknüpfung mit der Steuerkraft erreichen:
(A) Wenn die Position positiv mittel (PM) ist, und die Geschwindikeit ist nahezu Null (ZR), dann ist die
Kraft negativ mittel (NM).
(B) Wenn die Position positiv klein (PS) ist, und die Geschwindigkeit ist positiv klein (PS), dann ist die
Kraft negativ klein (NS).
(C) Wenn die Position positiv klein (PS) ist, und die Geschwindigkeit ist negativ klein (NS), dann ist die
Kraft nahezu Null (ZR).
(D) Wenn die Position negativ mittel (NM) ist, und die Geschwindigkeit ist nahezu Null (ZR), dann ist
die Kraft positiv mittel (PM).
(E) Wenn die Position negativ klein (NS) ist, und die Geschwindigkeit ist negativ klein (PS), dann ist die
Kraft positiv klein (PS).
(F) Wenn die Position negativ klein (PS) ist, und die Geschwindigkeit ist positiv klein (NS), dann ist die
Kraft nahezu Null (ZR).
(G) Wenn die Position nahezu Null (ZR) ist, und die Geschwindigkeit ist nahezu Null (ZR), dann ist die
Kraft nahezu Null (ZR).
Geschw.
Position
NB
NM
NS
ZR
PS
PM
PB
NM
NS
ZR
PS
PM
(D) PM
(E) PS
(F) ZR
(G) ZR
(C) ZR
(B) NS
(A) NM
5. Zugehörigkeitsfunktionen
Diese Funktionen für Position, Geschwindigkeit und Kraft sind einfache lineare
Funktionen:
83
Die Regeln werden aus dem Wissen über den Prozeß festgelegt
210
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Regel (E)
Wegverteilung
NM NS
PS
PM
-2
2
Geschwindigkeitsverteilung
NS
PS
NM
Kraftverteilung
NS
PS
PM
1.0
0.5
-1
1
-1
1
-400 -200
200 400
Regel (G)
Wegverteilung
NM NS
PS
PM
-2
2
Geschwindigkeitsverteilung
NS
PS
NM
Kraftverteilung
NS
PS
PM
1.0
0.5
-1
1
Wegverteilung
NM NS
PS
PM
-2
2
-1
1
Geschwindigkeitsverteilung
NS
PS
-400 -200
NM
200 400
Kraftverteilung
NS
PS
PM
1.0
0.5
-1
1
-1
1
-400 -200
200 400
Abb. 3.1-23: Darstellung zur Ermittling der Kraftverteilung
6. Ermittlung der Fuzzy-Kraft
Das Steuersystem soll bspw. vom Prozeß den Geschwindigkeitswert v = -0.5 (m/s)
und die Position x = -0.2 (m) übergeben. Mit Hilfe der Fuzzy-Regeln und den
Zugehörigkeitsfunktionen sind dann die Wahrheitswerte für Geschwindigkeit und
Position auszurechnen.
7. Berechnung des Schwerpunkts
Generell gilt für diese Berechnung einer beliebigen Funktion in x-Richtung:
(8) S x 
 dx  x  f ( x(
 dx  f ( x)
211
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Da die vorliegende Fläche aus mehreren Teilstücken besteht, müssen die
Einzelstücke getrennt aufsummiert werden:
(9) S x 
  dx  x  f
k
( x)
k
  dx  f
k
( x)
k
Die Fläche setzt sich aus linearen Funktionsabschnitten zusammen (, die der
Beziehung f(x) = ax + b entsprechen). Das führt, in (9) eingesetzt, zu:
(10) S x 
  dx  (a
k
k
 x 2  b k  x)
  dx  (a
k
 x  b)
k
Die Integration dieses Ausdrucks und Eingabe der Grenzen für die einzelnen
Funktionsabschnitte (, dabei soll für das Teilstück f k(x) der Anfangspunkt (PAk(xAk,yAk)
und der Endpunkt PEk(XEk,yEk) gelten,) führt zu:

bk 
bk  


2
 a k / 3  x Ek    x Ak   a k / 3   


3
2 
k 
(11) S x 
b 
b 
 

k x Ek  a k / 2  x Ek  2k   x 2Ak  a k / 3  2k  


 x
2
Ek
In (11) fehlen noch die Koeffizienten a k und bk für die einzelnen Funktionsabschnitte
(Berechnung aus den Anfangs- und Endpunkten der einzelnen Teilstücke):
ak 
y Ek  y Ak
x Ek  x Ak
b k  y Ak  a k  x Ak
8. Applet
http://fbim.fh-regensburg.de/~saj39122/schh/index.html
212
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.2.3.2 Anwendungsbeispiel: Roboter-Steuerung mit Fuzzy-Control
http://fbim.fh-regensburg.de/~saj39122/schkl/index.html
3.1.2.3.3 Anwendungsbeispiel: Beetle-Driver
http://fbim.fh-regensburg.de/~saj39122/fhll/index.htm
3.1.2.3.4 Anwendungsbeispiel: Kugeldrum
http://fbim.fh-regensburg.de/~saj39122/NN/braunRoidl/index.html
3.1.2.3.5 Anwendungsbeispiel: PingPong (KHF vs FC)
http://fbim.fh-regensburg.de/~saj39122/schsch/index.html
213
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.3 Regelbasierte Systeme
3.1.3.1 Fuzzy-Logik regelbasierter Systeme
Ein regelbasiertes System besteht aus einem System von Inferenzregeln und einem
Inferenzschema, das die Verarbeitungsvorschrift enthält, nach der (scharfe)
Eingangsgrößen xi mit Hilfe der Inferenzregeln zu (scharfen) Ausgangsgrößen yj
verarbeitet werden.
x
1
......
x
Regelbasiertes
System
y
n
Abb. 3.1-25: Regelbasiertes System mit n Eingangsgrößen und einer Ausgangsgröße:
Regelbasis:
R1: WENN x1 = A11 ... UND xi = A1i ... UND xn = A1n DANN y = B1
...
Rj: WENN x1 = Aj1 ... UND xi = Aji ... UND xn = Ajn DANN y = Bj
Rm: WENN x1 = Am1 ... UND xi = Ami ... UND xn = Amn DANN y = Bm
x1, x2, ... , xn : Eingangsfrößen
A1i, A2i, A3i, ... , Ami: linguistische Terme der Eingangsgröße xi
y: Ausgangsgröße
B1, B2, ... , Bm: linguistische Terme der Ausgangsgröße
resultierede Fuzzy-Menge
Einem aktuellen Satz von Eingangsgrößen wird mit Hilfe des Inferenzschemas (unter
Beachtung der Regelbasis) eine Fuzzy-Menge zugeordnet, die aus den Ergebnissen
aller Regeln zusammnegesetzt ist:
R1: min(11 ( x1' ),..., 1n ( x 'n ),  B1 ( y))   B'1 ( y)
.......
Rj: min( j1 ( x1' ),...,  jn ( x 'n ),  Bj ( y))   B' j ( y)
.......
Rm: min( m1 ( x1' ),...,  mn ( x 'n ),  Bm ( y))   B'm ( y)
Verbunden durch den ODER-Operator max entsteht die resultierende Fuzzy-Menge:
 res  max( B'i ( y),...,  B' m ( y))
Aufgabe der Fuzzy-Control (Defuzzifizierung) ist das Finden einer scharfen
Ausgangsgröße y:
214
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
x
1
......
x
Fuzzifizierer
Regelbasis
Inferenzschema
Defuzzifizierer
y
n
Abb.3.1-26: Komponenten eines regelbasierten System
3.1.3.2 Defuzzifizierung
Das Resultat der Fuzzy Inferenz ist eine Menge von Zugehörigkeitsfunktionen für die
Terme der linguistischen Ausgangsgrößen. Diese Fuzzy-Resultat muß man in
scharfe Größen des zulässigen Bereichs umwandelon. Es gibt eine Reihe von
Defuzzifizierungs-Methoden, deren Basis empirische Ergebnisse und heuristische
Methoden bilden.
3.1.3.2.1 Methode der plausibelsten Lösung
Die plausibelste Lösung entspricht am besten den Bedingungen in der Regelbasis.
Von allen Termen wird der Term mit dem maximalen Wert der
Zugehörigkeitsfunktion ausgesucht. Dann findet man den größten Wert der
Zugehörigkeitsfunktion, die den scharfen Wert der Ausgangsgröße definiert. Zu
diesen Methoden gehört:
-
Left of Maximum
Das Ergebnis ist der maximale Wert der Zugehörigkeitsfunktion, der ganz links liegen muß
Mean of Maximum
Das Ergebnis ist der maximale Wert der Zugehörigkeitsfunktion, der in der Mitte liegen muß
Right of Maximum
Das Ergebnis ist der maximale Wert der Zugehörigkeitsfunktion, der ganz rechts liegen muß
RoM
LoM
MoM
Es wird nur das Maximum gesucht
Abb.: Zugehörigkeitsfunktionen für einzelne Terme einer linguistischen Variablen
Nur die Regel mit dem höchsten Erfüllungsgrad bei einer vorgegebenen
Eingangsgröße wird betrachtet. Das Maximum der zugehörigen Ausgangs-FuzzyMenge bestimmt die scharfe Ausgangsgröße. Die Maximum-Methode wird bei der
Fuzzy-Modellierung am besten dadurch vorbereitet, daß die Ausgangsmenge jeder
Regel einzeln vorgegeben wird. Es muß bei der Modellierung darauf geachtet
215
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
werden, daß immer mindestens eine Regel aktiv ist, da sonst keine Entscheidung
gefällt wird.
Die Methode ist besonders geeignet für Probleme der Mustererkennung.
3.1.3.2.2 Methode des besten Kompromiss
Bei diesen Methoden wird der scharfe Wert als Schwerpunkt der
Zugehörigkeitsfunktionsfläche berechnet. Es werden zwei Verfahren verwendet:
1. Center of Maximum (Schwerpunkte der Singletons)
Die Zugehörigkeitsfunktionen der einzelnen Terme werden durch typische Werte ersetzt und
dann deren Schwerpunkte gesucht.
2. Center of Gravity (Flächenschwerpunkt)
Es wird der Flächenschwerpunkt aller Terme der Ausgangsvariablen gesucht
Center of Maximum
Dieses Verfahren ersetzt die Zugehörigkeitsfunktion für jeden Ausgangsterm durch
seinen typischen Wert und die scharfe Ausgangsgröße y res wird als Gewichtspunkt
von allen typischen Werten berechnet.

2
1
3
y res
Abb.: Das Verfahren Center of Maximum
Die scharfe Größe kann folgendermaßen berechnet werden:
l
y res 

i 1
l
i

i 1
yi
i
y res ... scharfer Wert (resultat)
yi ... Koordinate der Ausgangsgröße des i-ten Terms
 i ... Wert der Zugehörigkeitsfunktion vom i-ten Term
216
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Center of Gravity
Das scharfe Resultat y res wird als die Koordinate der Schwerpunktfläche, die durch
Vereinigung von Teilflächen entstanden ist, bestimmt. Die Teilflächen sind die
Flächen unter den Zugehörigkeitsfunktionen der einzelnen Terme.
y res
Abb.: Center of Gravity
Die scharfe Größe y res ist gleich
y res 

res
( y ) ydy
res

res
( y )dy
res
bzw.
y 


i
y res
res
( yi )
i
res
( yi )
i
 res ( y ) ... Zugehörigkeitsfunktion der ganzen Fuzzy-Menge des Ausgangs
217
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.3.3 Anwendungen
3.1.3.3.1 Inverses Pendel
Die nachfolgende Abbildung zeigt einen Stab, der über ein Pendelgelenk auf einem
Wagen befestigt ist. Durch Vor- und Rückbewegen des Wagens soll der Stab
aufrechtstehend gehalten werden84.
 Winkel
Mg : Gewicht des Wagens
mg : Gewicht des Pendels

2L
mg
x : Gewicht des Pendels
2L : Länge des Pendels
KV
KH
Mg
KZ
K V : vertikale Kraft am Gelenk
K H : horizontale Kraft am Gelenk
K Z : ziehende Kraft am Wagen
g
I
: Fallbeschleunigung
: Trägheitsmoment des Stabs
KV
.
Abb. 3.1-26: Modell des kopstehenden Pendels
1. Mathematisches Modell
Die Steuerung der Bewegungsrichtung und der Richtung des Wagens kann über das
folgende Differentialgleichungssystem beschrieben werden:
(1) I  ''  KV  sin   KH  L  cos 
(2) KV  m  g   m  L  ( ''  sin   '2  cos )
(3) KH  m  x ' '  m  L( ' '  cos   '2  sin )
(4) KZ  KH  M  x''
 : Winkel, 2  L : Länge des Pendel, x : Position des Wagens, m : Masse des Pendels,
M : Masse des Wagens, x : Position des Wagen, KV : vertikale Kraft am Gelenk, K H :
m
horizontale Kraft am Gelenk, KZ : ziehende Kraft am Wagen, g  9.81 2
s
1
Fallbeschleunigung, I   m  L2 : Trägheitsmoment des Stabs in Bezug auf das
3
Drehgelenk
84
vgl. Heinrich Rommelfanger: Fuzzy-Logik basierte Verarbeitung von Expertenregeln in OR Spektrum (1993)
15:31-42
218
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
2. Lösungsmöglichkeiten
1. Man könnte dieses Differentialgleichungssystem in ein Differenzengleichungssystem verwandeln und für die jeweils gegebenen Anfangsbedingungen
die Lösung mit Computerberechnung bestimmen. Dieses Verfahren ist aber sehr
rechenaufwendig und daher nicht in der Lage, die zur Steuerung des Wagens
benötigten Ergebnisse rechtzeitig zu liefern..
2. Man vereinfacht das Problem durch Annahme zusätzlicher Restriktionen.
Yamakawa85 schlägt die Annahme   1( rad) 86vor. Unter dieser Annahme läßt
sich das Differentialgleichungssystem (1) - (4) zu einem linearen Gleichungssystem
vereinfachen:
(5) ( I  m  L2 )  ' '  m  L  x ' '  m  L    0
(6) m L  '' (m  M )  x''  KZ
3. Fuzzy Control
-
Interpretation des Winkels
 bzw. der Winkelgeschwindigkeit  ' und der Geschwindigkeit
x ' des Wagens als linguistische Variable
-
Ermitteln der zu den linguistischen Variablen passenden Zugehörigkeitsfunktionen
Aufstellen der Regeln
A. Wenn  gleich PM und ' gleich ZR, dann wähle x' gleich PM
B. Wenn  gleich PS und ' gleich PS, dann wähle x' gleich PS
C. Wenn  gleich PS und ' gleich NS, dann wähle x' gleich ZR
D. Wenn  gleich NM und ' gleich ZR dann wähle x' gleich NM
E. Wenn  gleich NS und ' gleich NS, dann wähle x' gleich NS
F. Wenn  gleich NS und ' gleich PS, dann wähle x' gleich ZR
G. Wenn  gleich ZR und ' gleich ZR, dann wähle x' gleich ZR
Diese Regeln lassen sich abgekürzt in der folgenden Tabelle darstellen:
'
PL
PM
PS
ZR
NS
NM
NL

NL
NM
NS
ZR
ZR
NM
PS
PM
PL
PS
ZR
NS
PM
ZR
Aus dieser Tabelle folgt: Bei jeweils 7 Ausprägungen je Fuzzy-Simulationsmodell
sind Zustände 7 2  49 möglich. Von Yamakawa wurden aber nur die Regeln zu 7
möglichen Zuständen in den Regelblock aufgenommen, da diese zur Steuerung des
Pendel ausreichen. Die linguistischen Variablen für  , ' und x' lassen sich über die
sog. tringularen Fuzzy-Zahlen mit linearen Referenzfunktionen beschreiben 87 .
85
auf ihn geht die Fuzzy-Control-Steuerung dieses Beispiels zurück, vgl. OR-Spektrum (1993) 15:31-42
0
0
1 rad  360 / 2    57, 295
87 vgl. Abb. 3.1-30
86
219
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Im konkreten Fall muß überprüft werden, ob die beobachtete Situation mit einer oder
mehreren in dem Regelblock beschriebenen Situationen übereinstimmt. Aus den
Erfüllungsgraden für die einzelnen Zustandsvariablen wird dann mit Hilfe des
Minimumoperators der Erfüllungsgrad der Regel bestimmt. Treffen mehrere Regeln
für eine konkrete Situation zu, dann bezeichnet man über die Max-Min-Inferenz die
unscharfe Vereinigungsmenge aller unscharfen Aktionen. Eine konkret ausführbare
Aktion
bestimmt
man
im
Defuzzifizierungsschritt
aus
dem
Flächenschwerpunktverfahren.
Bsp.: Vorgegeben sind  bzw. ' (vgl. Pfeile in Abb. 3.1-30). Aktiviert werden bzgl.
 die Regeln A, B, C, bzgl. ' die Regeln A, C, E, D, G. Betroffen sind demnach nur
die Regeln A und C. Regel A feuert und aktiviert eine Inferenzmenge in x' unter PM.
Regel C feuert und aktiviert die Infernzmenge in x' unter ZR.
Bestimme mit Hilfe der Abb. 3.1.30 die zu den Inferenzmengen zugehörigen Flächen
und ermittle die resultierende Größe nach der Schwerpunktmethode.
3. Implementierung
Eine Implementierung (mit einer umfassenden Erkärung der linguuistischen
Variablen bzw. FUZZY-Sets zum invertierten Pendel) zeigt das MEILE-Projekt:
"Fuzzy-Shell zur Implementierung eines invertierten Pendels" ( http://fbim.fhregensburg.de/~saj39122/gheinz/Index.html).
220
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
A
Zugehörigkeitsgrad
NL
NM
NS
1.0
Zugehörigkeitsgrad
PS
PM
NL
PL
NM
NS
1.0
ZR
B
C
G
NL
NL
NM
NM
NM
NS
NS
NS
1.0
PM
NL
PL
NM
NS
E
D
NL
NL
NM
NM
NM
NS
NS
NS
NM
NS
1.0
1.0
PM
NL
PL
NM
NS
1.0
ZR
0.0
Zugehörigkeitsgrad
0.0
Zugehörigkeitsgrad
0.0
Zugehörigkeitsgrad
PS
PM
NL
PL
NM
NS
1.0
PS
PM
NL
PL
NM
NS
1.0
ZR
ZR
ZR
0.0
Zugehörigkeitsgrad
0.0
Zugehörigkeitsgrad
0.0
Zugehörigkeitsgrad
1.0
PS
PM
NL
PL
NM
NS
1.0
1.0
PS
PM
NL
PL
NM
NS
1.0
ZR
PM
NL
PL
NM
NS
1.0
PM
NL
PL
NM
NS
1.0
ZR
ZR
0.0
Zugehörigkeitsgrad
0.0
Zugehörigkeitsgrad
0.0
Zugehörigkeitsgrad
PS
PM
NL
PL
NM
NS
1.0
PS
PM
NL
PL
NM
NS
1.0
ZR
ZR
ZR
0.0
Zugehörigkeitsgrad
0.0
Zugehörigkeitsgrad
0.0
Zugehörigkeitsgrad
1.0
PS
PM
NL
PL
ZR
0.0
NM
NS
1.0
PS
PM
NL
PL
0.0
Abb. 3.1-30: Darstellung der linguistischen Ausprägungen
221
PM
PL
PS
PM
PL
PS
PM
PL
PS
PM
PL
PS
PM
PL
NM
NS
1.0
PS
PM
PL
ZR
ZR

PS
0.0
Zugehörigkeitsgrad
PS
ZR
1.0
PL
ZR
0.0
Zugehörigkeitsgrad
PS
PM
0.0
Zugehörigkeitsgrad
PS
ZR
1.0
PS
ZR
ZR
0.0
Zugehörigkeitsgrad
NL
NL
PL
0.0
Zugehörigkeitsgrad
PS
ZR
F
PM
ZR
0.0
Zugehörigkeitsgrad
NL
Zugehörigkeitsgrad
PS
'
 , ' und x'
0.0
x'
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.3.3.2 Fuzzy-Truck-Trailer
http://fbim.fh-regensburg.de/~saj39122/wang/index.html
3.1.3.3.3 Kugelkasten
http://fbim.fh-regensburg.de/~saj39122/schg/index.htm
3.1.3.3.4 Water-Mix
http://fbim.fh-regensburg.de/~saj39122/robhei/wma.html
3.1.3.3.5 Demonstration einer Fuzzy-Logik Steuerung eines Rennwagens durch eine
Rennstrecke
http://fbim.fh-regensburg.de/~saj39122/feld/demo/index.html
3.1.3.3.6 Fuzzy-Robot
http://fbim.fh-regensburg.de/~saj39122/NN/vogler/index.html
222
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.4 Mamdani und Fuzzy-Regler vom Typ Sugeno
Man unterscheidet in der Praxis 2 Typen von Fuzzy Regeln: Mamdani- und SugenoRegeln.
Mamdani-Regeln
Sie haben folgende allgemeine Form:
R j : IF x1 is A1( j ) and ... and x n is An( j ) THEN y is B ( j )
Es sind formalisierte Regeln, die aus einer durch IF und THEN eingeschlossenen
Prämisse bestehen und in der dem THEN folgenden Konklusion. A1 bis An sind
liguististische Variable, sie werden mit den linguistischen Termen x1 und x n
verglichen.
IF
AND
THEN
1
min
x1
x2
y
1
min
x1
scharfer Messwert
x2
y
scharfer Messwert
1
induzierte Ausgabe
Fuzzy-Menge
y
Abb.: Auswertung zweier Regeln bei einem Mamdani-Regler
223
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Sugeno-Regeln
Sie unterscheiden sich von den Mamdani-Reglern nur insofern, dass ihre
Konklusionen nicht mehr als unscharfe Werte angegeben werden, sondern
reellwertige Zahlen sind.
Die Fuzzy-Regeln werden in der Form
R j : IF x1 is A1( j ) and ... and x n is An( j ) THEN y j  C 0, j  C1, j  x1  ...  C n , j  x n
angegeben. Jede Regel liefert dann als Ergebnis des Bedingungsteils gerade den
Erfüllungsgrad  j : min(  A j ( x1 ),...,  A j ( xn )) . Als Resultat y j der Regel j erhält man
n
1
y j   ( j ) . Die Auswertung aller Regeln
Gesamtergebnis
1
r
y

j 1
r
j
 j
j 1
r
y j


j 1
j
(1<=j<=r) führt zu dem
Rj
 1 ( j )
r

j 1
j
Dies ist ein scharfer Wert, der nicht mehr defuzzifiziert werden muß. Voraussetzung
für diese Regler ist die Verwendung von monotonen Zugehörigkeitsfunktionen für die
Ausgabe-Fuzzy-Mengen88.
IF
AND
THEN
1
min
x1
x2
y
y1
1
min
x1
x2
y
y2
scharfer Messwert
scharfer Messwert
Abb.: Auswertung zweier Regeln bei einem Sugeno-Regler
88 Der Experte muß das gewünschte Regelverhalten in (expliziter) mathematischer Form angeben.
224
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.5 Fuzzy Associative Memories (FAM)89
3.1.5.1 Verknüpfungen zwischen Fuzzy-Systemen
Fuzzy-Mengen beschreiben Punkte in einem mehrdimensionalen Raum (ndimensionaler Einheitswürfel): I n  [0,1]n . Innerhalb dieses Raums interessieren die
Distanzen zwischen den Punkten. Sie dienen zur Messung der Größe und
Fuzzifizierung der Fuzzy-Mengen und können bestimmen, inwieweit eine FuzzyMenge Untermenge einer anderen Fuzzy-Menge ist. Im nächsten Schritt können
Abbildungen zwischen Fuzzy-Räumen betrachtet werden. Das Rahmenwerk zu
Fuzzy-Mengen ist numerisch und mehrdimensional. Strukturiertes Wissen wird in ein
numerisches Rahmenwerk eingebracht, das Modifizierung und Anpassung von
Fuzzy-Systemen erlaubt, vielleicht sogar mit Techniken zu Neuronalen Netzen und
der Statistik (direkt mit Beispieldaten aus dem Problembereich).
Ein Fuzzy-Set definiert ein Punkt in diesem Raum, ein Fuzzy-System bildet FuzzyMengen auf Fuzzy-Mengen ab. So gesehen ist ein Fuzzy-System eine
Transformation
S :In  I p
I n umfaßt alle Fuzzy-Mengen des Urbild- oder Eingabebereichs: X  {x1 ,..., xn }
I p umfaßt alle Fuzzy-Untermengen bzw. den Ausgabebereich: Y  { y1 ,..., y p }
X und Y können Untermengen der Räume R n und R p sein. Die Mächtigkeit der
zugehörigen Fuzzy-Mengen liegt bei F (2 X ) und F (2Y ) 90.
Allgemein bildet ein Fuzzy-System Familien aus Fuzzy-Mengen auf Familien anderer
Fuzzy-Mengen ab: S : I n1  ...  I nr  I p1  ...  I ps ab
Durch die Transformation S : I n  I p werden kontinuierlich Fuzzy-Systeme
unterschiedlicher Räume miteinander verknüpft (assoziiert). Abgeschlossene
Eingaben werden in abgeschlossene Ausgaben abgebidet (Fuzzy Associative
Memories). Das einfachste FAM bestimmt die FAM-Regel oder Assoziation ( Ai , Bi ) ,
die den p-dimensionalen Fuzzy-Set Bi mit dem n-dimensionalen Fuzzy-Set Ai
verbindet. Regeln, z.B. „WENN der Verkehr in dieser Richtung stark ist, DANN
schalte auf längere Grünphase“, können in einer nach der Hebbschen Regel
gestalteten FAM-Korrelations-Matrix aufgenommen werden. Anstelle der Matrix
benutzt man die Bezeihung (STARK, LAENGER) in einer aus linguistischen Termen
gebideten FAM-Bank.
Allgemein bestimmt und bearbeitet (parallel) ein FAM-System F : I n  I p einen
FAM-Bereich von m FAM-Regeln ( A1 , B1 ),..., ( Am , Bm ) . Jede Eingabe A zu einem
FAM-System aktiviert jede gespeicherte FAM-Regel zu einem bestimmten Grad. Das
minimale FAM, das ( Ai , Bi ) speichert, bildet die Eingabe zu A in Bi ' ab. Je mehr A
Ausführliche Beschreibung und Dokumentation (S. 299 – 335) in: Bart Kosko: Neural Networks and FuzzySystems, Prentice Hall, Englewood Cliffs, 1992
90 Irgendeine Funktion f : X  Y , die Punkte von X in Punkte von Y abbildet, kann zur Abbildung von Fuzzy89
f : F (2 X )  F (2Y ) . 2 X beschreibt
die Mächtigkeit der Fuzzy-Mengen von X , das sind alle Fuzzy-Untermengen von X .
Untermengen aus X in Fuzzy-Untermengen aus Y erweitert werden:
225
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Ai ähnelt, desto mehr ähnelt Bi ' B . Die korrespondierende Ausgabe-Fuzzy-Menge
B kombiniert die partiell aktivierten Fuzzy-Mengen B1 ' ,..., Bm ' . B ist ein gewichteter
Durchschnitt der partiell aktivierten Fuzzy-Mengen:
B  w1  B1 '...  wm  Bm '
wi : Bewertung der Stärke der Fuzzy-Verknüpfung ( Ai , Bi )
FAM Regel 1
( A1 , B1 )
( A2 , B2 )
B1 '
B2 '
w1
FAM-Regel 2
...........
w2
.....
A

..........
B
Defuzz.
yj
.....
wm
FAM-Regel m
( Am , Bm )
Bm '
Abb.: Fuzzy-System-Architektur
Binary Input-Output -FAM-Systeme (BIOFAMs) konvertieren den Vektor B in einen
skalaren Ausgabewert y  Y (Defuzzifizierung), der als Massenpunkt bzw.
Schwerpunkt der Masse B beschrieben wird:

y


y   B ( y )dy




 B ( y )dy
226
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.5.2 Adaptive FAMs
Fuzzy-Systeme verknüpfen Ausgabe-Fuzzy-Sets mit Eingabe-Fuzzy-Sets und
verhalten sich so wie assoziative Speicher. Das Fuzzy-Inferenzschema berechnet
die Ausgabe-Fuzzy-Sets B j ' , gewichtet sie mit den Gewichten w j , summiert sie auf
zur Produktion des Fuzzy-Set B : B   w j  B j '
j
Adaptive Fuzzy-Systeme nutzen Beispieldaten bzw. Algorithmen zu Neuronalen
Netzen bzw. aus der Statistik zur Auswahl der Koeffizienten w j . Die Adaption
verändert die Systemstruktur. Ein adaptives FAM ist eine mit der Zeit sich
verändernde Abbildung zwischen Fuzzy-Räumen. Im einfachsten Fall bestimmt der
Eingabe-Fuzzy-Set einen Punkt im Raum I n , der Ausgabe-Fuzzy-set setzt einen
Punkt im Raum I p . Die Transformation S bestimmt ein Fuzzy-System, wenn
S : I n  I p ist. S verknüpft Fuzzy-Untermengen des Ausgaberaums Y mit FuzzyUntermengen des Eingaberaums X . S definiert ein adaptives Fuzzy-System, falls
dS
 0.
S sich mit der Zeit ändert:
dt
Ein adaptives FAM ist ein mit der zeit sich verändernde Abbildung zwischen FuzzyRäumen. FAM-Regeln werden aus Trainings-Daten erzeugt. Die Beispieldaten
kommen aus dem Ein-/Ausgabe-Produktraum. FAM-Abbildungen definieren Cluster
im Ein-/Ausgabe-Produktraum. Die adaptive Prozedur erzeugt aus den TrainingsDaten gewichtete FAM-Regeln. Weiteres Training modifiziert eine gewichtete Menge
aus FAM-Regeln.
3.1.5.3 Erzeugen von adaptiven FAM-Regeln
1 ,...,  k bestimmen k Quantifizierungs-Vektoren des Ein-, Ausgaberaums I n  I p . In
I n  p definiert  j die jte Spalte der Verbindungsmatrix. Die Verbindunsmatrix hat n+p
Zeilen und k Spalten.  j soll sich mit der Zeit ändern91. Die Vektoren  j schätzen
die Dichte oder Verteilung der FAM-Regeln in I n  I p ab, d.h. sie betonen eine
geschätzte FAM-Regel mit einem Gewicht. Je mehr sich geschätzte Vektoren um
m
eine FAM-Regel scharen, desto größer ist das Gewicht in B   wk  Bk ' . Nimm an,
k 1
es gibt 15 Bezugspunkte zu FAM-Regeln in I  I
n
p
(und k > 15). k i Vektoren  j
sammeln sich im iten Bezigspunkt. Die Cluster, die k i zählen, sind geordnet
( k1  k 2  ...  k15 ). Mit k  k1  ...  k15 ergibt sich das adaptive FAM-Regel-
ki
.
k
Praktisch will man häufig nur die am häufigsten frequentierten FAM-Regeln oder nur
Regeln mit mindestens einer minimalen Freqenz wmin .
Gewichtsschema: wi 
91
z.B. im Rahmen von Wettbewerbs-Lernvorgängen (Differential Competive Learning, DCL).
227
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.1.5.4 Adaptives BIOFAM-Clustering
Ein-/Ausgabedaten können direkt FAM-Systeme generieren. Adaptives BIOFAMClustering überführt die Daten in Regeln, das Fuzzy-System lernt die kausalen
Abhängigkeitsmuster. Das System lernt, welche Steuerungsmuster der Eingabe
welchen Mustern der Ausgabe entsprechen. Das System schätzt die kausalen
Abhängigkeitsmuster, wenn es als Steuerung fungiert. Adaptive BIOFAMs ballen
sich im Eingaberaum X  Y . Der Produktraum ist kleiner als der mächtige
Produktraum I n  I p . Die adaptiven Vektoren  j sind nun zweidimensional anstatt
(n+p)-dimensional. Auf der anderen Seite erfordert wetteiferndes BIOFAM-Clustering
mehr Ein-/Ausgabedatenpaare ( xi , y i )  R 2 als Fuzzy-Set-Beispieldaten.
BIOFAM-Clustering
entnimmt
Beispieldaten
dem
Ein-/Ausgabestrom
( x1 , y1 ), ( x2 , y2 ),... . Unüberwachtes, wetteiferndes Lernen verteilt die k quan-tifizierten
Vektoren 1 ,...,  k auf X  Y . Das Lernen ordnet sie den verschieden FAM-Zellen Fij
zu. Die FAM-Zelle überlappt die „Nicht-Fuzzy-Räume“ von X  Y . Die BIOFAMZellen Fij überdecken X  Y .
Fij
enthält
k ij
Quantifizierungs-Vektoren. Die Zelle zählt
Häufigkeitsdiagramm bis alle k ij aufsummiert k ergeben. wij 
k ij
k
k ij , definiert ein
gewichtet dann die
FAM-Regel „WENN X Ai ist, DANN ist Y Bj“.
In der Regel konzentriert sich die Verteilung auf wenige Zellen der FAM-Bank und im
wesentlichen werden die vom Benutzer ausgewählten Regeln für das Gleichgewicht
bestätigt bzw. ergänzt.
228
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2 Regelungssysteme
3.2.1 Klassische Regelungssysteme
3.2.1.1 Begriffe aus der Regelungstechnik
Bei einem Regelkreis handelt es sich um ein System, in dem eine zeitveränderliche
Größe in bestimmter Weise beeinflusst werden soll, z.B. um diese auf einen
gewünschten Wert (Sollwert w) zu bringen und dort zu halten. Die zu beeinflussende
Größe ist die Regelgröße x, das gegebene System ist die Regelstrecke.
1. Aufbau eines Regelkreises
Ein Regelkreis besteht aus einer Regeleinrichtung und einer Regelstrecke
Störgrößen
RegelFührungsgröße abweichung Regler- und
w
xw = x-w Steuereinrichtung
Regelgröße
y
Strecke
gemessene Regelgröße
Meßeinrichtung
Abb. 3.2-1: Prinzipschaltung einer Regelung
Die Aufgabe eines Regelkreises ist: Der Ausgangswert (Istwert) soll dynamisch
möglichst genau, schnell und schwingungsfrei dem Eingangswert (Sollwert) folgen.
Die Eingangsgröße ist die Führungsgröße des Regelkreises, die Ausgangsgröße ist
die Regelgröße. Zur Anpassung der Regelgröße an die Führungsgröße wird ein
Istwert gemessen und mit dem Sollwert verglichen. Die Differenz ist der
Eingangswert der Regeleinrichtung. Sie wird durch den Regler beeinflußt und am
Reglerausgang der Strecke als Stellgröße zur Verfügung gestellt.
Wesentliches Merkmal einer Regelung im Unterschied zu einer Steuerung ( oder
einem Stellglied) ist ein geschlossener Wirkungskreislauf, der ein automatisches
Nachführen des Istwerts gemäß dem Sollwert ermöglicht.
2. Festwertregelung
Eine Festwertregelung liegt vor, wenn der Sollwert (w) einen festen Wert besitzt.
Aufgabe der Regelung ist es, dafür zu sorgen, dass die Regelgröße diesen
vorgeschriebenen festen Sollwert einhält, ohne dass Störungen, die auf den Prozeß
einwirken, von nennenswertem Einfluß sind. Die Regeleinrichtung muß also bei
einem Festwertregler Störwirkungen gut ausregeln können: das Störverhalten muß
gut sein. Zur Festwertregelung werden auch die Fälle gerechnet, bei denen der
229
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Sollwert gelegentlich oder nur langsam geändert aber auch wieder für eine längere
Zeit konstant gehalten wird.
3. Führungsregelung
Bei einer Führungsregelung ist der Sollwert (w) eine Funktion der Zeit oder einer
anderen Größe. Die Aufgabe der Regelung besteht darin, den Vewrlauf der
Regelung möglichst genau dem Verlauf der Führungsgröße anzugleichen. Die
Regeleinrichtung wird hierbei auf ein möglichst gutes Führungsverhalten ausgelegt,
die Regelgröße soll der Führungsgröße möglichst genau folgen.
3.2.1.2 Beschreibungsmöglichkeiten (für dynamische Systeme)
1. Beschreibung dynamischer Systeme
Zur Regelung eines Systems mit den Methoden der konventionellen
Regelungstechnik muß ein Modell für das dynamische Verhalten des Systems
aufgestellt werden.
Falls F die Menge aller Funktionen f: R -> R bezeichnet und xe (t )  F die
Eingangsfunktion für das System (z.B. die Regelstrecke) ist, dann liegt das Ziel in
der Bestimmung der Funktion T: F -> F, so dass xa (t )  T ( xe (t )) der Verlauf des
Ausgangssignals des Systems wiedergibt. Die Funktion T beschreibt das
Übertragungsverhalten des betrachteten Systems.
Lineare Systeme. Die konventionelle Regelungstechnik beschränkt sich auf das
Betrachten linearer Systeme. Von linearen Systemen spricht man, wenn sich das
Ausgangssignal als lineare Überlagerung der Systemanworten mehrerer
Eingangssignale beschreiben lässt, d.h. wenn das Superpositionsprinzip gilt:
n
n
i 1
i 1


n
 k i xai (t )   k iT xei (t )  T  k i xe (t )
i 1
i
Die Beziehung zwischen Eingangs- und Ausgangssignal kann häufig über
Differentialgleichungen beschrieben werden.
2. Beschreibung im Zeitbereich (in Form einer Differentialgleichung)
2.1 Bsp.: Einfaches RC-Netzwerk
u (t)
e
ua ( t )
Abb. 3.2-4: Tiefpass
230
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Ein Widerstand und ein Kondensator sind in Reihe geschaltet und an beide
Bauelemente eine Eingangsspannung ue (t ) gelegt. Die Ausgangsspannung ua (t )
läßt sich als Funktion der Eingangsspannung beschreiben:
u e ( t )  R  i( t )  u a ( t )
du a ( t ) 1
  i( t )
dt
C
Durch Einsetzen erhält man eine Differentialgleichung erster Ordnung:
RC
du a ( t )
 u a (t)  u e (t)
dt
Für diese Differentialgleichung ist die Lösung mit den
u e ( t  0)  0 und u e ( t  0)  u 0 :
Randbedingungen
u a ( t )  u 0  (1  e  t / RC )
Vorgegeben wird eine sprunghafte Anregung der Höhe u0 . Das Verhalten der
Ausgangsgröße ist die Sprungantwort.
u(t)
u e (t)
ua(t)
t
Abb. 3.2-5: Zeitliches Verhalten
2.2 Darstellung des Zeitverhaltens durch die Übergangsfunktion
Die übliche grafische Darstellung eines Regelungsblocks in einem Strukturbild ist
eine skizzierte Abbildung seiner Sprungantwort in einem Rechteck
231
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
ue(t)
t
ue(t)
ua(t)
ua(t)
t
Abb. 3.2-6: Darstellung des zeitlichen Verhaltens durch die Übergangsfunktion
Den Verlauf, den die Ausgangsgröße nach einer sprungartigen Eingangsänderung
hat, bezeichnet man als Übergangsfunktion.
2.3 Kennzeichnung von Regelstrecken
Es gilt: Die Regelstrecke hat als Eingangsgröße die Stellgliedanordnung y(t) und als
Ausgangsgröße die Regelgröße x(t). Für lineare Übertrager kann man das
Zeitverhalten einer Regelstrecke durch die allgemeine Differentialgleichung
dx
d2x
'
''
n
'''
''
, x  2 , usw. beschreiben.
S n  x ...S 3  x  S 2  x  S1  x  S 0  x  y mit x 
dt
dt
Die höchste Ableitung der beschreibenden Gleichung kennzeichnet die Ordnung der
Regelstrecke. Man spricht von einer Regelstrecke n-ter Ordnung, wenn ihr
Zeitverhalten exakt oder wenigstens mit guter Näherung durch eine
Differentialgleichung n-ter Ordnung dargestellt werden kann.
Weiterhin unterscheidet man
- Regelstrecken mit Ausgleich
- Regelstrecken ohne Ausgleich
2.3.1 Regelstrecken mit Ausgleich
Hier strebt die Regelgröße nach z.B. sprungartiger Stellgliedsverstellung für t  
einen neuen Beharrungszustand an. Für t   verschwinden alle Ableitungen x’, x’’,
1
... und der Endwert ist die Größe x 
. Der einfachste Fall ist eine Strecke der
S0
Ordnung 0 mit der Gleichung S 0  x  y .
Die meisten Regelstrecken zeigen Verzögerungen, d.h. die Ausgangsgröße folgt
nicht unmittelbar einer sprungartigen Eingangsgröße, sondern mit einer zeitlichen
Verzögerung. Die einfachste verzögerte Regelstrecke ist die Regelstrecke 1.
232
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Ordnung mit der Gleichung S1  x'S 0  x  y bzw. TS  x' x  VS  y mit TS 
VS 
S1
und
S0
1
. Die Lösung dieser Gleichung bei einer Sprungfunktion ist bekanntlich:
S0
x  VS  (1  e  t / TS )
x
TS
VS
t
Abb. 3.2-7: Übergangsfunktion
Eine Regelstrecke 2. Ordnung wird durch die Differentialgleichung
S 2  x' 'S1  x'S 0  x  y
beschrieben. Das ist die bekannte Schwingungsgleichung, die bspw. in der Mechanik
das Verhalten eines Feder-Masse-Systems mit Dämpfung beschreibt. Die
Übergangsfunktion eines solchen Systems zeigt ein oszillatorisches Verhalten
2.3.2 Regelstrecken ohne Ausgleich
Bei einer sprungartigen Änderung der Eingangsgröße wird die Ausgangsgröße vom
vorliegenden Beharrunszustand weglaufen, ohne wieder einen neuen
Beharrungszustand in dem Bereich der Ausgangsgröße anzunehmen.
3. Beschreibung im Frequenzgangbereich
Führt man aufwendigere Regelstrukturen auf Differentialgleichungen im Zeitbereich
zurück, so sind diese sehr schnell unhandlich und unübersichtlich. Deshalb ist es
günstiger, eine Transformation in den Frequenzbereich vorzunehmen (sog. LaplaceTransformation). Speist man ein Übertragungsglied mit einer sinusförmigen
Eingangsgröße, so ist das Übertragungsverhalten als Funktion der Frequenz die
Darstellung im Frequenzbereich. Ist bspw. u a ( t )  U 0  e jt , dann gilt:
du a ( t )
 j    U 0  e jt
dt
Wählt man für die Spannung die komplexe Darstellung mit der abkürzenden
Schreibweise j  p , so ergibt sich für das Beispiel des RC-Netzwerks:
p  T  u a ( p)  u a  ( p)  u e ( p) mit T=RC)
233
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
oder
u a ( p)  F( p)  u e ( p) mit F( p) 
1
1 T p
Definition des Frequenzgangs
Der Frequenzgang eines Übertragers ist eine Funktion, die das Amplitudenverhältnis
und die Phasenverschiebung in Abhängigkeit von der Frequenz beschreibt. Ein
Übertrager wird durch die allgemeine Differentialgleichung
a m  x a( m )  ...  a 2  x a''  a1  x a'  a 0  x a  e0  xe  e1  xe '...  en  xe( n )
in seinem Zeitverhalten beschrieben. Ist die Eingangsgröße eine Sinusschwingung
mit der Amplitude xe0, so kann diese in komplexer Schreibweise in der Form
x e  x e0  e jwt
dargestellt werden. Im eingeschwungenen Zustand ist die Ausgangsgröße eine
Schwingung gleicher Frequenz, jedoch mit einer Phasenverschiebung .
x a  x a 0  e j( t  )
Dann ist:
x e '  j  x e0  e jwt
x a '  j  x a 0  e jwt
x e ''  ( j) 2  x e0  e jwt
x a ''  ( j) 2  x a 0  e jwt
x e '''  ( j) 3  x e0  e jwt
.....
x (en)  ( j) n  x e0  e jwt
x a '''  ( j) 3  x a 0  e jwt
.....
x (am)  ( j) m  x a 0  e jwt
Durch Einsetzen in die allgemeine Differentialgleichung, die das Zeitverhalten eines
Übertragers beschreibt, ergibt sich:



x a 0  e j( t  )  a m  ( j ) m ...a 2  ( j ) 2  a 1  j  a 0  x e 0  e jt e n  ( j ) n ...e1  j  e 0

Der Frequenzgang F() erhält man, indem man das Verhältnis Ausgangsgröße zu
Eingangsgröße bildet:
F( j) 
x a 0  e j( t  ) x a 0 j e n  ( j) n ...e1  j  e 0

e 
x e0
x e 0  e jt
a m ( j) m ...a 1  j  a 0
Man kann den Frequenzgang unmittelbar aus der gegebenen Differentialgleichung
heraus berechnen, z.B.:
T22  x''T1  x' x  y
x( p)(T22  p 2  T1  p  1)  y( p)
234
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
F( p) 
x( p)
1

y( p) 1  T1  p  T22  p 2
3.2.1.3 Lineare (stetige) Regler
In der Regelungstechnik werden häufig Regler eingesetzt, die zur Bestimmung der
Stellgröße y , die Regelabweichung x w sowie deren Ableitung x w ' und das Integral
t
x
w
( )d verwenden
0
1. Proportionalregler (P-Regler)
Jede Änderung der Regelabweichung (xw) bewirkt - im Idealfall - eine sofortige
proportionale Änderung der Stellgröße:
y  VR  x w
VR ist der Verstärkungsfaktor des Reglers. Die Übergangsfunktion ist die
Sprungfunktion.
y
xw
xw
VR
t
t
Abb. 3.2.10: Übergangsfunktion eines idealen P-Reglers
Hat der Regler Verzögerungen, so lautet seine allgemeine Gleichung:
Tm  y ( m )  ...  T2 y ''  T1  y '  y  VR  x w
Der Regler nimmt nur dann eine Verstellung des Stellglieds vor, falls
Regelabweichnung vorliegt. Eine Störgröße, die in einer Regelstrecke
Regelabweichnung hervorruft, kann demnach durch einen P-Regler in
Wirksamkeit nur eingeschränkt werden. Er kann eine Regelabweichnung
vollständig beseitigen.
Generell beschreibt man den Proportional-Regler durch
eine
eine
ihrer
nicht
y (t )  K p x w (t )
K p ist die Proportionalverstärkung.
Vorteile des Proportionalreglers sind seine Schnelligkeit und sein einfacher Aufbau.
Nachteilig ist, dass Regelkreise mit Proportionalregler eine bleibende Regeldifferenz
aufweisen.
235
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
KP
x w (t )
y (t )
Abb.: Symbol P-Regler
2. Proportionalregler mit Differentialanteil (PD-Regler)
Die Ausgangsgröße y wird noch zusätzlich durch die Änderungsgeschwindigkeit der
Regelgröße bestimmt. Der Regler spricht also bereits auf den Differentialquotienten
von x w an.
y  VR  ( x w  TV  x w' )
TV (bestimmt den D-Anteil) wird Vorhaltezeit genannt.
xw
y
VRxw
t
Abb. 3.2.11: Übergangsfunktion eines idealen PD-Reglers
Gerätetechnisch läßt sich eine Differentiation nicht verwirklichen. Die verwendeten
Regler haben mindestens eine Verzögerung 1. Ordnung gemäß der Gleichung:
T1  y  VR  ( x w  TV  x w' )
Allgemein kann ein D-Regler durch folgende Gleichung beschrieben werden:
y(t )  K D
x w (t )
t
K D ist die Differentialverstärkung
KD
x w (t )
y (t )
Abb.: Symbol D-Regler
Da der D-Regler nur auf die Änderung der Reglabweichung reagiert, ist er allein nicht
zu gebrauchen. Er wird nur ergänzend mit dem P- oder PI-Regler eingesetzt.
236
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3. Integralregler (I-Regler)
Die Stellgröße ist proportional dem zeitlichen Integral über die Regelabweichung
y  c R   x w  dt
bzw.
Tm  y ( m )  ...  T2 y ''  T1  y '  y  c R   x w dt
Eine Verstellung des stellglieds wird solange erfolgen, wie eine Regelabweichung xw
vorhanden ist. Der regler wird somit in der Lage sein, den Einfluß einer störgröße auf
die zu regelnde Größe zu beseitigen. Nach Ablauf des Regelvorgangs wird die
Regelabweichung zu Null werden.
xw
y
c Rx w
t
1
Abb. 3.2.15: Übergangsfunktion eines I-Reglers
Allgemein beschreibt man den I-Regler durch:
t
y(t )  K I  xw ( )d
0
K I ist die Integralverstärkung
KI
x w (t )
y (t )
Abb.: Symbol I-Regler
4. Proportional-integrale Regler
Beim Anfangsverhalten hat der P-Regler gegenüber dem I-Regler Vorteile, beim
Ausgangsverhalten ist es umgekehrt. Der PI-Regler verbindet die jeweiligen Vorteile
der beiden Regler durch eine Parallelschaltung miteinander. Die Verstellung des
Stellglieds erfolgt nach dem Betrag der Regelabweichnung (P-Anteil) und nach dem
zeitlichen Integral (I-Anteil).
Tm  y ( m )  ...  T2 y ''  T1  y '  y  VR  x w  c R   x w dt  VR  ( x w 
237
1
 x w dt )
Tn 
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Die Zeitkonstante Tn=VR/cR wird Nachstellzeit genannt. Der PI-Regler nimmt so lange
eine Verstellung des Stellglieds vor, bis keine Regelabweichung vorhanden ist.
VRxw
Tn
Abb. 3.2.16: Übergangsfunktion eines (idealen) PI-Reglers
5. Proportional-integrale Regler mit D-Anteil
Er läßt durch durch die Parallelschaltung eines P-, I- und D-Anteils realisieren:
- Der P-Anteil sorgt für allgemein günstiges Regelverhalten
- Der I-Anteil sorgt für stationäre Genauigkeit
- Der D-Anteil sorgt für schnelle Ausregelung
Das Zeitverhalten beschreibt folgende Differentialgleichung:
y
VRxw
t
Tn
Abb. 3.2.20: Übergangsfunktion eines (idealen) PID-Reglers
Industrielle PID-Regler zeigen nur in seltenen Fällen eine lineare
Übertragungscharakteristik. Jeder Regler besitzt eine Stellgrößenbeschränkung mit
einem unteren und oberen Grenzwert (ymin, ymax).
Auf der anderen Seite besitzt der "reale PID-Regler" eine Vielzahl zusätzliche
Optionen, die das Regelverhalten im Betrieb verbessern sollen. Dazu gehört bspw.
eine Modifikation der D-Anteils zur Verringerung der Empfindlichkeit gegenüber
Störsignalen. Ein idealer Differenzierer würde bei sich zeitlich sehr schnell
ändernden Eingangsgrößen hohe Störamplituden liefern und damit das
nachgeschaltete Stellglied überbeanspruchen. Statt des idealen Differenzierers
y  Tv  x w'
wird ein sogenanntes Vorhalteglied mit der Differentialgleichung
T  y '  y  TV  x w'
eingesetzt.
238
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Das Verzögerungsglied T1 ist so zu wählen, daß die gewünschte Störunterdrückung
erreicht wird und der differenzierte Charakter des Reglers erhalten bleibt.
Mathematisch kann ein PID-Regler durch folgende Differentialgleichung beschrieben
werden:
t
y(t )  K P xw (t )  K I  xw ( )d  K D
0
xw (t )
t
Der PID-Regler bildet das Stellsignal aus der Regeldifferenz durch proportionale
Verstärkung, durch Integration der Regeldifferenz, durch Differentation der
Regeldifferenz.
KP
KI
+
x w (t )
y (t )
+
+
KD
x w (t )
y (t )
Abb.: Symbol PID-Regler
239
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2.1.4 Zustandsregler
Ihnen stehen mehrere, im Idealfall alle Zustandsgrößen der Regelstrecke zur
Verfügung. Hierdurch kann u.a. ein wesentlich verbesserte Regelverhalten erzielt
werden. Der Preis dafür ist der erhöhte Meßaufwand für die Ermittlung der
Zustandsgrößen.
Bsp.: Das sog. "Inverse Pendel"
Es besteht aus einem fest montierten
Motor der bei Aufprägung eines
Ankerstroms i ein Drehmoment M auf das
Pendel mit der Masse m ausübt. Das
System besitzt 2 Zustandsgrößen: Die
Winkelauslenkung
und
die

Winkelgeschwindigkeit ' .
m
 '
l
i
M
Abb. 3.2-30: Auf dem Kopf stehendes Pendel
Die Regelungsaufgabe besteht darin, das Pendel in seiner Ruhelage zu halten bzw.
dorthin zurückzuführen, wenn es durch eine äußere Störung ausgelenkt wird.
Bei der Lösung mit einem Zustandsregler wird neben der Winkelauslenkung  noch
die Winkelgeschwindigkeit ' zugeführt. Dadurch wird eine größere Regelgüte
erzeugt, allerdings um den Preis einer zusätzlichen Meßstelle.
Generell werden bei der Zustandsregelung gemessene Systemgrößen mit dem
Rückführungsvektor rT multipliziert. Die Beschreibung der Stellgröße umfaßt:
 y max

y  r T  x
y
 min
Alles, was größer ist als ymin und kleiner ist als ymax wird durch rTx beschrieben. Die
Wahl des Rüchführungsvektors rT setzt ein Modell des zu regelnden System voraus.
240
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2.1.5 Kennlinien- und Kennfeldregler
Kennlinienregler umfassen i.a. nichtlineare Übertragungsglieder, deren Übertragungsverhalten durch eine Beziehung
a  F (e)
Beschreibbar ist. "F" ist in grafischer Form als Kennlinie gegeben. Kennlinieregler
sind stationäre Regler, da sie keine Eigendynamik besitzen.
Bsp.: Zweipunktregler
a
amax
e
amin
Zweipunktregler dienen zur einfachen Temperaturregelung. Der Regler besitzt dann
bspw. die Arbeitspunkte "0" und "amax", die Regelstrategie lautet dann etwa:
WENN Solltemperatur noch nicht erreicht, DANN Heizen mit voller Kraft.
WENN Solltemperatur erreicht, DANN Heizung aus.
Eine unmittelbare Verallgemeinerung des Kennlinienreglers auf den Fall mehrerer
Regler-Eingangsgrößen
a  F (e1 , e2 ,..., em
stellen Kennfeldregler dar.
241
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2.2 Fuzzy-Regelungssysteme
1. Struktur
Grundlage für den Entwurf von Reglern mit Methoden der klassischen
Regelungstechnik92 ist ein mathematisches Modell, das meistens aus
Differentialgleichungen besteht, die das dynamische Verhalten des Systems in
Abhängigkeit von den Eingangs- und Stellgrößen mögflichst exakt nachbilden. Im
Rahmen der Fuzzy-Regelung verzichten man auf das Erstellen eines
mathematischen Modells. Statt dessen vesrsucht man eine Regelstrategie zu
beschreiben, die z.B. durch Befragung oder Beobachtung eines kompetenten
Anlagenfahreres gewonnen wird, der das technische System bedienen kann. Hinter
diesem Ansatz steht dieEinsicht, dass Menschen meistens in der Lage sind, sowohl
einfache als auch komplexe Systeme recht gut zu beherrschen, ohne dass sie dazu
ein mathematisches Modell mit Differentialgleichungen aufstellen müssten.
Analog zum konventionellen Regler kann ein Fuzzy-Controller so interpretiert
werden: Implementierung eines Übertragungsverhaltens mit Eingangsgrößen, die die
über den Zustand des Prozesses bzw. der Regelstrecke zur Verfügung stehenden
Informationen darstellen, sowie die Ausgangsgrößen für den Prozeß.
X1
Y1
Fuzzy-Controller
...
Ym
Xn
Abb. 3.2-40: Fuzzy-Controller mit den Eingangsgrößen Xi und der Stellgröße Yj
Von außen betrachtet, zeigt der Regler keinerlei Unschärfe, d.h.: Sowohl Eingangsals auch Ausgangsgrößen sind scharfe Werte. Die Unschärfe liegt im Innenleben
des Reglers.
Ein Fuzzy-Regler benötigt eine Wissensbasis, in der die Regelstrategie in Form
geeigneter umgangssprachlicher Regeln festgelegt wird, z.B.: „Wenn die Differenz
zwischen Soll- und Ausgangswert und die Änderung dieser Differenz ungefäht null
sind, dann sollte die Stellgröße etwa konstant gehalten werden“.
92
vgl. 3.2.1
242
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Eingangsgrößen
X1
WENN ... UND ...
DANN ...
WENN ... UND ...
DANN ...
WENN ... UND ...
DANN ...
...
Stellgröße
Y
...
...
Xn
Inferenz
Fuzzyfizierung
Defuzzifizierung
Abb. 3.2-41: Logische Struktur eines Fuzzy-Controllers
Eingangsund
Stellgrößen
sind
linguistische
Variable
und
durch
Zugehörigkeitsfunktionen charakterisiert. Durch Fuzzifizierung werden die scharfen
Eingangsgrößen in unscharfe Größen überführt. Die Inferenzmaschine generiert im
2. Schritt mit Hilfe des vorgegebenen Regelwerks an den fuzzifizierten
Eingangsgrößen eine unscharfe Stellgröße. Diese wird schließlich durch
Defuzzufizierung wieder in ein scharfes Signal zurückverwandelt.
Die Umsetzung der 3 Arbeitsschritte kann in der on line Berechnung der Stellgröße
für die aktuelle Kombination der Eingangsgrößen bestehen. Dazu geht am
folgendermaßen vor:
(1) Bestimmen des Erfüllungsgrads jeder Regel
- Ermitteln des Erfüllungsgrads für die einzelnen Prämissen (WENN-Teile) der Regeln
- Verknüpfen der einzelnen Erfüllungsgrade über den UND- oder ODER-Operator (z.B. MIN- bzw.
MAX-Operator)
(2) Ermitteln der zugehörigen Stellgrößen-Fuzzy-Mengen für alle aktiven Regeln
(3) Ermitteln der resultierenden Fuzzy-Menge durch Überladen aller StellgrößenFuzzy-Sets
(4) Ermitteln der scharfen Stellgröße durch Defuzzifizierung
Fuzzy-Regelungssysteme
Regelungssysteme:
zeigen
die
243
gleichen
Strukturen
wie
klassische
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Regelbasis
Fuzzifizierung
-
Inferenzmechanismus
Defuzzyfizierung
Strecke
FC
Abb. 3.2-42: Grundstruktur eines Fuzzy-Reglers
2. Mamdani-Regler und Fuzzy-Regler vom Typ Sugeno
Ein Fuzzy-Regler, der auf der Basis unscharfer Regeln arbeitet, liefert ein unscharfes
Ergebnis in der Form einer Fuzzy-Menge, die noch „defuzzifiziert“ werden muß, um
einen eindeutigen Wert für die Stellgröße zu erhalten. Eine häufig angewandte
heuristische Defuzzifizierungs-Strategie ist die Wahl des Stellwerts unter dem
Schwerpunkt93 der durch die Fuzzy-Menge bzw. Zugehörigkeitsfunktionen begrenzte
Fläche.
Beim sogenannten Mamdani-Regler94 bildet man dafür das Minimum der
Zugehörigkeitsgrade der aktuellen Werte zu dem in der entsprechenden Regel
auftretenden linguistischen Terme bzw. Fuzzy-Mengen.
Bei Fuzzy-Reglern vom Sugeno-Typ95 gibt man anstelle der linguistischen Werte für
die Stellgröße scharfe Werte vor, so dass auf Fuzzy-Mengen für die Stellgröße
verzichtet werden kann.
3. Fuzzy-Entwurfsschritte
(1) Wahl der Meßgrößen mit den daraus abgeleiteten Größen als Eingangs-größen
des Fuzzy-Controller sowie der Stellgröße als Ausgangsgröße
(2) Festlegung der möglichen Wertebereiche für die Ein- und Ausgangsgrößen
(Skalierung der linguistischen Variablen)
(3) Definition der linguistischen Terme und ihre Zugehörigkeitsfunktionen (Fuzzy
Sets) für alle linguistischen Variablen
(4) Aufstellen der Regelbasis (Regelwerk) durch sinnvolle Wahl der logischen
Verknüpfungen:
Die Anzahl der zu wählenden Regeln hängt ab von der Zahl der Eingangsgrößen, der Zahl der
Ausgangsgrößen und der Zahl der linguistischen Variablen aller Größen ab. Bei 2 Eingangsgrößen
und einer Ausgangsgröße mit jeweils 5 sie beschreibenden linguistischen Variablen müssen 52 =
25 Regeln gefunden werden.
(5) Festlegen der Inferenzmaschine (Operatoren, Inferenzmethode, Datentyp,
Defuzzifizierungsmethode)
93
Center-of-Gravity-Methode (COG)
vgl. 3.1.4
95 vgl. 3.1.4
94
244
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
(6) Simulation des Regelkreises, falls ein Modell der Regelstrecke vorhanden ist.
Das Modell muß nicht ein exaktes Modell sein, sondern kann ebenfalls mit einem
Fuzzy-System verbal beschrieben werden.
(7) Optimierung
(8) Stabilitätsanalyse über offline- oder online-Prüfverfahren oder über
mathematische Verfahren
4. Übertragungsverhalten von Fuzzy-Controllern
Ein automatisches Regelungssystem gibt zu jeder Kombination der Eingangsgrößen
einen Stellwert an. In einem Fuzzy-Control-System verwendet man dafür aktuell
gemessene bzw. errechnete Eingangsgrößen.
Bsp.: Demonstration der Eingangsgrößen (Winkelauslenkung  , und Winkelgeschwindigkeit ' ) bei der Regelung des auf dem Kopf stehenden Pendels 96. Die
Werte für die Ausgangsvariable ("Kraft") beim Stab-Wege-Problem werden
durch die dritte Dimension dargestellt.
Abb. 3.2-50: Regelfläche beim Stab-Wege-Problem
Der für das Stab-Wege-Problem entwickelte Fuzzy-Regler ist vollständig bestimmt
durch eine Funktion, die zu jeder Kombination der Eingangsgrößen den richtigen
96
vgl. Stab-Wege-Problem, MEILE-Projekt ( ... )
245
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Wert der Stellgröße angibt. Die zugehörige bildliche Darstellung ist das Kennfeld des
Reglers97.
Fuzzy-Controller weisen statisches und - von Sonderfällen abgesehen - nichtlineares
Übertragungsverhalten auf, das durch Kennlinien bzw. Kennlinienfelder 98
beschrieben werden kann. Das Übertragungsverhalten ist abhängig von Anzahl,
Form und Anordnung der linguistischen Ein- und Ausgangsgrößen, der Regelbasis
sowie
Verknüpfungsoperatoren,
Inferenz-mechanismus
und
Defuzzifizierungsverfahren und kann durch Änderung einzelner Fuzzy-Mengen und
Regeln lokal beeinflußt werden. Fuzzy-Controller gehören zur Klasse der Kennlinienbzw. Kennfeldregler.
3.2.2.2 Einfaches Modell eines Fuzzy-Reglers
3.2.2.2.1 Diskrete Regelung
Ein konventioneller Regler (z.B. PI-Regler) berechnet den Einstellwert nach der
Gleichung: y  K P x w  K I  x w ( )d . Durch Differenzierung und Diskretisierung erhält
t
man aus dieser Gleichung (mit 't' als Zeitpunkt):
y(t )  K P xw (t )  K I xw (t ) .
y (t ) ist die Veränderung der Stellgröße, x w (t ) ist die Regelabweichung (der Fehler)
und x w (t ) ist die Änderung des Fehlers. Es gilt: xw (t )  xw (t )  xw (t  1)
3.2.2.2.2 Fuzzy-Regelung
Ein Fuzzy-Regler benutzt eine Wissensbasis, die aus Fuzzy-Regeln besteht. Diese
Regeln haben allgemein die Form:
wenn (Prozesszustand) dann (Stellwert)
d.h. Aufgrund eines bestimmten Prozesszustands wird eine Veränderung des
Stellwerts bestimmt. Die Regel stellt eine Art kausale Beziehung zwischen
Prozesszustand und Stellwert her, der im analytischen Ausdruck des PI-Reglers
nicht vorliegt. Der wesentliche Unterschied liegt aber in der Art der für die Variablen
verwendeten Werte:
97
98
vgl. http://fbim.fh-regensburg.de/~saj39122/gheinz/Index.html
vgl. 3.2.1.5
246
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
x w (t )
x w (t )
y (t )
negativ
die aktuelle Prozeßausgabe x liegt um
einen Betrag entsprechend dem Wert der
Größe über dem Sollwert w(t )
die aktuelle Prozessx(t )
ausgabe
ist
gegenüber dem vorhergehenden
Wert
x(t  1) um einen
Betrag
entsprechend
dem Wert der Größe
gewachsen.
der aktuelle Wert der
Steuerungsausgabe
y (t  1) ist um einen
Betrag
entsprechend
dem Wert der Größe zu
verkleinern.
null
positiv
die aktuelle Prozessausgabe die aktuelle Prozessausgabe x
liegt
um
einen
Betrag
x liegt am Sollwert w(t )
entsprechend dem Wert der
Größe unter dem Sollwert w(t )
die aktuelle Prozessausgabe
x(t ) hat sich gegenüber
dem vorhergehenden Wert
x(t  1) nicht verändert.
die
aktuelle
Prozessausgabe
x(t ) hat sich gegenüber dem
vorhergehenden Wert x(t  1)
um einen Betrag entsprechend
dem Wert der Größe verringert.
der aktuelle Wert der der
aktuelle
Wert
der
Steuerungsausgabe
y
(
t

1)
Steuerungsausgabe
y (t  1) bleibt unverändert. ist
um
einen
Betrag
entsprechend dem Wert der
Größe zu verkleinern.
Für alle drei Variable wird dieselbe Menge linguistischer Werte gewählt. Die
Regelmenge ist in der folgende Tabelle dargestellt:
x w (t ) \
NB
NM
NS
N
PS
PM
PB
NB
NB
NB
NB
NM
NS
N
NB
NB
NB
NM
NS
N
PS
NB
NB
NM
NS
N
PS
PM
NB
NM
NS
N
PS
PM
PB
NM
NS
N
PS
PM
PB
PB
NS
N
PS
PM
PB
PB
PB
N
PS
PM
PB
PB
PB
PB
x w (t )
NB
NM
NS
N
PS
PM
PB
247
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2.3 Hybride Systeme
3.2.3.1 Neuronale Regler
Neuronale Regler benötigen ähnlich wie Fuzzy-Regeler kein methematischphysikalisches Modell des zu regelnden Systems. Wichtig ist hier vor allem: die
Lernfähigkeit des Künstlichen Neuronalen Netzes.
1. Off-line learning mit fester, unverändert vorliegender Lernaufgabe
Die einfachste Form eines neuronalen Reglers besteht aus einem (mehrschichtigen)
Perceptron, das mit der (erweiterten) Delta-Regel (Backpropagation) anhand einer
festen Lernaufgabe trainiert wird. Dabei ist es notwendig, daß das betrachtete
(technische) System bereits anderweitig geregelt werden kann99 und Meß-,
Stellgrößen erfaßbar sind. Zumindest müssen für repräsentative Eingaben die
entsprechenden Werte der Stellgrößen bekannt sein. Beispieldaten müssen
vorliegen, das Lernverfahren verlangt mehrere vollständige Durchläufe (Epochen)
bei einer unverändert vorliegenden Lernaufgabe (Offline learning). Da dieser Art
neuronaler Regler auf direktem Wege das Verhalten des Bedieners nachbilden,
werden sie als Klone (clones) oder "überwachte Regler" bezeichnet.
Bsp.: Fahrzeugsteuerung auf einem frei definierbaren Rundkurs über ein FuzzyControl-System (Erlernen der Fahrweise) mit Speicherung in einem neuronalen
Netz100.
2. Verstärkendes Lernen mit bewerteter freier Lernaufgabe
Die Idee dieses Lernverfahrens besteht in einer Belohnung des Neuronalen Netzes,
wenn die Ausgabe zu einer guten Veränderung geführt hat, bzw. in einer Bestrafung,
wenn die ausgelöste Veränderung schlecht ausgefallen ist. Es ist nur erforderlich,
die Ausgabe bzw. die durch sie in der Umgebung des Netzwerks hervorgerufene
Veränderung als gut oder schlecht bewerten zu können. Die korrekte Ausgabe für
ein gegebenes Eingabemuster braucht nicht bekannt zu sein (freie Lernaufgabe).
Der Vorgang des verstärkenden Lernens kann in folgende fünf Schritte unterteilt
werden:
(1) Ein Muster ip wird ausgewählt und dem Neuronalen Netz präsentiert.
(2) Ein Muster ip wird propagiert, bis das das Netz seine Ruhephase erreicht hat.
(3) Die Bewertung f(op) der Ausgape op wird ermittelt
(4) Die Netzstruktur W wird anhand von op verändert.
Gewichte, die verstärkend auf die aktuelle Ausgabe wirken, werden bestraft, wenn der Ausgabe
eine schlechte Bewertung zugeordnet wird. Sie werden belohnt, falls der Ausgabe eine gute
Bewertung bekommt. Mit Gewichten, die abschwächend auf die aktuelle Ausgabe wirken, wird
dementsprechend entgegengesetzt verfahren. Die Belohnung und Bestrafung äußert sich in einer
Erhöhung bzw. in einer Erniedrigung ihres Betrags.
99
z.B. durch einen erfahrenen Operator bzw. durch ein Fuzzy-Conrol-System
http://fbim.fh-regensburg.de/~saj39122/feld/demo/Applet1.html
100
248
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
(5) Falls kein Abbruchkriterium definiert ist bzw. ein gegebenes nicht erfüllt ist, wird
mit Schritt (1) fortgefahren. Anderenfalls ist der Lernvorgang beendet.
3.2.3.2 Vergleich Neuronale Netze mit Fuzzy-Systemen in Hinblick auf
Schätzungen zu Ein-/Ausgabefunktionen (Regeln)
1. Vergleich Neuronale Netze mit Fuzzy-Systemen
Neuronale Netze und Fuzzy-Systeme schätzen Ein-/Ausgabefunktionen und
verhalten sich wie assoziative Speicher. Sie sind an kein bestimmtes Modell
gebunden. Sie fordern keine mathematische Beschreibung, wie die Ausgabe von der
Eingabe abhängt und lernen an Beispielen. Sie verwenden numerische Ansätze.
Neuronale Netze und Fuzzy-Systeme unterscheiden sich in der Art, wie sie die
Beispieldaten zur Schätzung benutzen. Das neuronale Feedforward-Netz ermittelt in
der Lernphase durch umfangreiche Iterationen mit Beispieldaten das dynamische
Systemverhalten. Das Fuzzy-System verlangt nur das (teilweise) Ausfüllen einer
linguistischen Regel-Matrix. Bei der Konstruktion des Systems können einige
numerische Eingaben (X) einigen numerischen Ausgaben (Y) zugeordnet sein.
2. Schätzen von Ein-/Ausgabe-Funktionen
Fuzzy-Systeme schätzen Funktionen mit Beispielen zu Fuzzy-Mengen ( Ai , Bi ) .
Neuronale Netze nutzen numerische Punkte ( xi , yi ) . Die beiden Formen zur Bildung
von Beispieldaten sind bestimmt durch Ein-/Ausgabe und bilden den Raum ( X  Y ) .
( Ai , Bi ) umfaßt eine Struktur, die der Meta-Regel „WENN Ai . DANN Bi “ vergleichbar
ist und eine Art linguistische Regel eines Expertensystems umfaß. Das FuzzySystem bestimmt jede linguistische Verknüpfung der Regel in eine numerische FAMAbbildung. Das Fuzzy Associative Memory (FAM101) verarbeitet numerische
Eingabedaten und erzeugt numerische Ausgaben.
Neuronale Netze und Fuzzy-Systeme schätzen Ein-/Ausgabe-Funktionen. Im
Gegensatz zu statistischen Abschätzungen werden Funktionen ohne ein
mathematisches Modell, das die Abhängigkeit der Ausgabe von der Eingabe
beschreibt, geschätzt. Es handelt sich um „Modell“-freie Abschätzungen. Sie können
aus Erfahrung lernen mit numerischen bzw. manchmal auch mit linguistischen
Beispieldaten.
3. Generieren von FAM-Regeln durch Adaptive FAM (AFAM) Systeme
Adaptive FAM (AFAM)102-Systeme generieren FAM-Regeln durch Trainieren.
101
102
vgl. 3.1.5
vgl. 3.1.5.4
249
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Applet: Abschätzen von Fuzzy-Regeln mit Hilfe eines Neuronalen Netzes für den
Fuzzy Truck-and-Trailer-Controler
4.1 Aufgabenstellung
Das Truck and Trailer-Applet demonstriert die Funktionsweise des „Adaptive FAM
Algorithmus“, der mit Hilfe eines Neuronalen Netzes Fuzzy-Regeln abschätzen kann.
Das System soll Fuzzy-Regeln finden, die die Steuerung eines Lastwagens mit
Anhänger ermöglichen. Der Laster wird durch den Fuzzy-Controller von einer durch
den Benutzer festgelegten Startposition rückwärts zu seinem Zielpunkt bewegt.
Abb.:
Zur Beschreibung des Systems wird herangezogen:
( x, y ) : Koordinaten des Endpunkts vom Anhänger
(u, v) : Koordinaten des Verbindungspunktes (Zugmaschine, Anhänger)
 t (phiTrailer): Winkel (-90 bis 270°), den der Anhänger mit der Horizontalen bildet
 c (phiCab): Winkel (-90 bis 90°), den die Mittelpunktlinie der Zugmaschine mit der
Mittelpunktlinie des Anhängers bildet
 : Steuerungswinkel (-30 bis 30°) zwischen Mittelpunktlinie der Zugmaschine und
Radeinschlag
 (Betha): Winkel, mit dem der Anhänger bei jedem Schritt angepaßt wird.
4.2 Funktionsweise des Applet (http://fbim.fh-regensburg.de/~saj39122/wangi/afam.htm)
250
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2.3.3 Kombinationen Neuronaler Netze und Fuzzy-Regler (Neuro-Fuzzy)
1. Erlernen einer Regelbasis
Das Erlernen linguistischer Regeln und / oder Zugehörigkeitsfunktionen steht im
Mittelpunkt einer Kombination von Fuzzy-Reglern mit Neuronalen Netzen. "Erlernen"
bedeutet: Vollständige Erzeugung einer Regelbasis bzw. von Zugehörigkeitsfunktionen, die die entsprechenden linguistischen Terme auf der Grundlage
von Beispieldaten modellieren.
Das Erlernen einer Regelbasis setzt die vorläufige Definition von
Zugehörigkeitsfunktionen voraus und ist auf drei verschieden Arten möglich:
(1) Das System beginnt ohne Regeln und bildet solange Regeln bis die Lernaufgabe
erfüllt ist.
(2) Das System beginnt mit allen Regeln, die aufgrund der Aufteilung der beteiligten
Variablen gebildet werden können und entfernt ungeeignete Regeln aus der
Regelbasis.
(3) Das Systen beginnt mit einer (evtl. zufällig gewählten) Regelbasis, die aus eine
festen Anzahl von Regeln besteht. Im Laufe des Lernvorgangs werden Regeln
ausgetauscht. Bei jedem Austauschvorgang muß die Konsistenz der Regelbasis
neu überprüft werden.
2. Kombinationsformen
Bei der Kombination von Neuronalen Netzen und Fuzzy-Systemen lassen sich zwei
Ansätze unterscheiden:
Kooperative Systeme: Das NN arbeitet unabhängig vom Fuzzy-System. Die
Kopplung der beiden Systeme besteht darin, dass Parameter des Fuzzy-Systems
durch das NN bestimmt bzw. optimiert werden. Das so optimierte Fuzzy-System
arbeitet dann im Betrieb ohne das Neuronale Netz.
Hybride Systeme: Vereinigung der Prinzipien: Neuronales Netz und Fuzzy-System.
Interpretation als spezielles NN wie als Fuzzy-System möglich. Eine Trennung ist
nicht mehr möglich.
3. Kooperative Systeme
Ein Fuzzy-System ist bestimmt durch
- Definition der unscharfen Mengen, d.h. der Zugehörigkeitsfunktionen, die hinter den
linguistischen Variablen stehen
- Angabe der Regeln, die die linguistischen Begriffe miteinander verknüpfen.
Mengen und Regeln sind durch wenige Parameter beschreibbar. Ein kooperatives
Neuro-Fuzzy-System kann entweder unscharfe Mengen bei feststehenden Regeln
lernen (Fall 1) oder die Regeln bein unveränderlichen unscharfen Mengen (Fall 2).
Fall 1: Zeigt ein Fuzzy-System mit vollständiger und fest vorgegebener Regelbasis
eine schlechte Leistung, dann führt man das auf eine nicht optimale Modellierung
251
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
der in den Regeln verwendeten unscharfen Mengen zurück. Die Konsequenz ist:
Anpassen der Parameter unscharfer Mengen in Richtung auf ein erwünschtes
Verhalten, d.h. Position und Gestalt der Zugehörigkeitsfunktion müssen geeignet
verändert werden. Dafür eignet sich ein modifiziertes BackpropagationLernverfahren, das anstelle der Gewichte die Lage und die Form der
Zugehörigkeitsfunktion verändert.
Es kann auch „on-line“ gelernt werden. Ein „on-line“ System lernt im lfd. Betrieb und
besitzt zu Beginn eine Regelbasis, die zunächst nur grob entworfene, unscharfe
Mengen verwendet. Während das System arbeitet, wird seine Leistung bewertet.
Weicht sie von der gewünschten Leistung erheblich ab, ist das Anlaß für eine
Fehlerkorrektur, z.B. nach dem Backpropagation-Verfahren.
Fall 2: Finden optimaler Regeln bei fest vorgegebenen unscharfen Mengen.
Geeignet sind hier bspw. selbstorganisierende Karten. Wie bei einer festen
Lernaufgabe wird dem Netz zunächst ein großes Sortiment an Beispielen vorgelegt.
Erst nach Abschluß der Trainingsphase werden in einem gesonderten
Rechenverfahren die gefunden Regelhäufigkeiten mit Hilfe der vorgegebenen
unscharfen Mengen ausgedrückt. Dadurch gewinnt das System ohne Vorwissen eine
Regelbasis.
On-line kann sogar mit Regeloptimierung gelernt werden. Allerdings ist ein solches
Verfahren nur praktikabel, wenn ein Versagen des Systems keinen allzu großen
Schaden verursacht, oder wenn man das System statt am echten Objekt an einer
Simulation üben läßt. Ein „on-line“ System kann weiterlernen und sich so an
Änderungen der Aufgabe anpassen. In diesem Fall werden die zur Optimierung
herangezogenen Neuronalen Netze (oder neuronalen Lernverfahren) nicht, wie sonst
üblich, nach Abschluß des Trainings aus dem System entfernt.
4. Hybride Systeme
Hybride Ansätze verschmelzen das Fuzzy System mit dem Neuronalen Netz.
Zu den wesentlichen Eigenschaften dieses Ansatzes zählen:
- Wissen wird in transparenten Regeln gespeichert.
- Verwendung linguistischer Ausdrücke
- Lernfähigkeit
252
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
x
r1
y
r2
r3
r4
r5
z
klein
mittel
groß
Abb.: Hybrides Neuro-Fuzzy-System nach dem NEFCON-Modell. Die Verbindungen zwischen den Neuronen
eintsprechen unscharfen Mengen. Durch die Strichstärke der Verbindungen wird die Zugehörigkeit zu einer
bestimmten Fuzzy-Menge ausgedrückt. Die Neuronen der Eingabeschicht entsprechen den Eingangsgrößen, die
der inneren Schicht Fuzzy-Regeln, die der Ausgangsschicht den Ausgangsgrößen. Regel r1 lautet bspw.: „Wenn
x klein ist und y groß, dann ist z mittel.
3.2.3.4 Neuro-FuzzyHybride
3.2.3.4.1 NEFCON bzw. NEFCLASS
1. Fuzzy Perzeptron
Das Fuzzy-Perzeptron ist ählich wie ein Multi-Layer-Perzeptron aufgebaut. Dabei
nutzt man aus, dass die Verarbeitung innerhalb des Fuzzy-Systems in zwei Schritten
erfolgt:
- Auswertung der Regeln (Inferenz)
- Vereinigung dieser Auswertung (Komposition)
Anstelle der Gewichte der einzelnen Verbindungen treten beim Fuzzy-Perzeptron die
unscharfen Mengen. Anstelle der gewichteten Summe und der Aktivierungsfunktion
tritt bei den Neuronen in der inneren Schicht die Fuzzyfizierung und die Inferenz, bei
den Neuronen der Ausgangsschicht die Komposition und die Defuzzyfizierung.
Der Lernalgorithmus zur Anpassung der Fuzzy-Mengen beruht auf einer Variation
des Backpropagation-Algorithmus. Ähnlich wie bei kooperativen Systemen müssen
folgende Einschränkungen getroffen werden:
- Unscharfe Mengen dürfen sich nicht in einen Bereich verschieben, der nicht mehr der Interpretation
des linguistischen Werts entspricht.
- Sicherstellen durch Kopplung von Verbindungen, dass anfangs gleiche unscharfe Mengen während
des Lernprozesses sich nicht unterschiedlich entwickeln. (Die Kopplung ist in Abb. durch Ringe um
die gekoppelten Verbindungen dargestellt.)
- Die entstehende Fehlerfunktion muß differenzierbar sein. Deshalb dürfen für Fuzzy-Mengen nur
differenzierbare Zugehörigkeitsfunktionen verwendet werden (vorzugsweise die Gaussche
Glockenkurve). Auch die Verfahren zur Inferenz und zur Komposition müssen durch Verfahren
ersetzt werden, die die Differenzierbarkeit der Fehlerfunktion aufrecht erhalten. Daher wird anstelle
der Minimumsbildung bei der Inferenz die Produktbildung verwendet. Die Maximumsbildung bei der
Komposition und die anschließende Deffuzzyfizierung wird durch einen Regler des Sugeno-Typs
ersetzt. Bei einem Regler des Sugeno-Typs handelt es sich um eine Einheit, die direkt aus den
253
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Werten der Inferenzbildung mit Hilfe einer Funktion einen Ausgangswert ermittelt. Die
Defuzzyfizierung ist dann nicht mehr notendig.
x1
x1
r1
x2
x2
r2
r3
r4
r5
r1
r2
1
y
r3
1
c1
r4
1
1
r5
1
c2
Abb.: Neuro-Fuzzy Syteme, die von einem Fuzzy Perzeptron abgeleitet sind
2. Erlernen der Fuzzy-Regeln
Für das Erlernen der Fuzzy-Regeln stehen zwei Methoden zur Verfügung:
1. Man beginnt ohne Regeln und fügt eine Regel nach der anderen hinzu bis das
System eine zufriedenstellende Leistung erbringt. Die Methode ist für onlineLernen nicht anwendbar, da man in der Lernphase Regeln Regeln durch Raten
einfügen und später evtl. aufwendig nachbessern müsste.
2. Man beginnt mit einer Basis aus allen möglichen erzeugbaren Regeln und streicht
nicht benötigte nacheinander wieder heraus. Diese Methode ist für online
lernende Modelle geeignet. Die Komplexität eines solchen Systems steigt jedoch
rasch mit der Anzahl der Eingangs-, der Ausgangsvariablen und der Anzahl der
Fuzzy-Mengen,da für jede Kombination eine Regel generiert werden muß. Bspw.
existieren für zwei Eingangsvariablen, eine Ausgangsvariable und eine FuzzyPartitionierung bereits 512 Regeln. Erhöht man die Zahl der Eingangsvariablen
auf 4, dann sind es bereits 32768 Regeln. Die Komplexität steigt also somit
exponentiell mit der Anzahl der Freiheitsgrade. Die Regelbasis ist nur für kleine
Systeme vollständig erlernbar. In vielen Fällen lassen sich jedoch für einen Teil
des Problems Regeln angeben, so dass nur die fehlenden Regeln hinzugefügt
werden müssen.
3. Das NEFCON-Modell
Es ist in der Lage einen gegebenen Mamdani-Kontroller zu optimieren, indem dieser
Kontroller zunächst in ein funktional äquivalentes Neuronales Netz transformiert wird,
das dann mit speziellen Lernverfahren trainiert und optimiert wird.
254
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Fuzzy-Fehler-Propagierung. Das NEFCON103-Modell benutzt folgende Variante des
Baclpropagation-Verfahrens: Es lernt online durch verstärkendes Lernen und
verwendet dazu einen Fuzzy-Fehler. Der Benutzer gibt eine Reihe von Regeln an,
die beschreiben, wann die Leistung des Systems gut und wann sie schlecht ist, z.B.:
Wenn die Temperatur angenehm ist, dann ist die Leistung hoch. Diese Regeln
werden die die eines Fuzzy-Reglers ausgewertet und zur Anpassung der SystemParameter (der Fuzzy-Mengen) herangezogen. Der Fuzzy-Fehler wird dabei als
(negatives) Verstärkungssignal genutzt und wie beim Backpropagation-Algorithmus
(beginnend bei der Ausgabeschicht) rückwärts durch das Netz propagiert. Dabei wird
es von den Regeleinheiten lokal zur Adaption der Fuzzy-Mengen genutzt.
Für jede Zugehörigkeitsfunktion muß in Abhängigkeit des Fuzzy-Fehlers ermittelt
werden, ob und wie sie zu verändern ist. Dazu werden nur soche
Zugehörigkeitsfunktion verändert, die mit den Regeleinheiten in Verbindung stehen,
deren Aktivierung ungleich null ist104.
Verstärkendes bzw. bestrafendes Lernen: Zur Realisierung von verstärkendem
Lernen muß entschieden werden, ob eine Regel für ihre Reaktion auf den aktuellen
Zustand zu belohnen oder zu bestrafen ist. Mit der Belohnung soll erreicht werden,
dass in einer gleichen Situation die Regel einen stärkeren Beitrag zur Regelaktion
leistet und sie somit positiv beeinflusstEine Bestrafung soll den Beitrag einer Regel abschwächen, um die Regelaktion
weniger negativ zu beeinflussen.
IF
THEN
1
oneu
oalt
belohnen
x
yalt yneu
IF
THEN
1
oalt
oneu
bestrafen
x
yneu yalt
Abb.: Belohnen und Bestrafen von Fuzzy-Mengen
103
NEural Fuzzy CONtroller, wurde Mitte der 90er Jahre an der TU Braunschweig von D. Nauk, F. Klawonn
und R. Kruse entwickelt
104 d.h. Regeln, die in der momentanen Situation einen Erfüllungsgrad von 0 aufweisen, lösen keine Adaption an
den Fuzzy-Mengen ihrer Prämissen und Konklusionen aus
255
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Das NEFCLASS-Modell
Dieses Modell ist ebenfalls von dem Fuzzy-Perzeptron abgeleitet, verzichtet aber auf
die Fuzzy-Gewichte in der zweiten Verbindungsebene. Die in dem Modell
eingesetzten Fuzzy-Regeln sind von der Form:
IF x1 IS A1 AND … AND xn IS An THEN class C1
Ai: Linguistische Terme
Die Konklusion der Regel besteht nur in einer Klassenzuteilung. NEFCLASS lernt
eine Regelbasis durch sukzessives Hinzufügen von Regeln, d.h. Knoten der inneren
Schicht. Anschließend werden die verschiedenen Fuzzy Mengen optimiert.
Idealerweise erhält man so einen Klassifikator, der in Form linguistischer Regeln
interpretiert werden kann.
NEFCLASS verwendet ein überwachtes Lernverfahren und benötigt eine feste
Lernaufgabe.
3.2.3.4.2 Anfis
ANFIS (Adaptive Network-based Fuzzy-Inferenz-System) implementiert Fuzzy
Regeln in einem Neuronalen Netz, das aus 6 Schichten besteht, die allerdings nicht
homogen aufgebaut sind. Die Neuronen verschiedener Schichten verwenden jeweils
verschiedene Aktivierungsfunktionen (z. B. Gaußfunktionen, Multiplikationen, usw. ).
Die Zugehörigkeitsfunktionen von Fuzzy-Prädikaten werden bspw. durch
Gaußfunktionen realisiert. Das Lernen des Reglers geschieht nur in wenigen
Schichten. Die richtige Zugehörigkeitsfunktionen müssen von Anfang an bekannt
sein, während die Parameter der Konklusionen (Sugeno-Form) gelernt werden.
3.2.3.4.2.1 Anfis-Netze für unterschiedliche Typen von Fuzzy-Kontrollern
Übersicht über die verschiedenen Arten von Fuzzy-Controllern
Aus den verschiedenen Arten von Fuzzy-Kontrollern
256
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
 Ai
Typ 1
 Bi
A1
B1
Typ 2
C1
Typ 3
C2
z1  ax  by  c
w1
 A2
z1
 B2
A2
B2
z 2  px  qy  r
w2
x
y
multiplication (or min)
z2
weighted average
z
w1 z1  w2 z 2
w1  w2
z
z
max
weighted average
z
w1 z1  w2 z 2
w1  w2
Z (centroid of area)
Abb.: Grafische Darstellung der Fuzzy-Controller Arten
lassen sich unterschiedliche Anfis-Netze entwickeln
- Anfis-Netz für Typ 1 Fuzzy-Kontroller
- Anfis-Netz für Typ 3 Fuzzy-Kontroller
Die Fuzzy-Kontroller von Typ1 und Typ3 kann man in ein Anfis-Netz umwandeln, das
genau dieselbe Funktionsweise hat. Der Vorteil dieser Vorgehensweise ist, daß man
anstatt den Fuzzy-Kontroller, ein Neuronales Netz heranzieht.
Für Typ 2 Fuzzy-Kontroller kann man nicht ohne weiteres ein Anfis-Netz aufbauen,
denn das Weitergeben von Fuzzy-Mengen kann man mit Neuronen nicht
nachbauen.
257
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Anfis-Netz für Typ 1 Fuzzy-Kontroller
 Ai
Typ 1
 Bi
A1
B1
C1
w1
f1
 A2
z
 B2
A2
f 
B2
C2
w1 f1  w2 f 2

w1  w2
w1 f1  w2 f 2
w2
x
Eingaben
y
layer 1
IF-Teil
f2
layer 2
layer 3
Regeln und Normierung
A1

x
z
w1

layer 4
THEN-Teil
layer 5
Ausgabe
w1
w1 f1
A2

w2 f 2
B1

y
B2

w2
w2
Abb.: Anfis-Netz für den Typ 1 Fuzzy-Kontroller mit 2 Regeln
Anfis für Typ 1 ist ein Feedforward-Netz mit 5 Schichten und Shortcuts. Es gibt nur in
der ersten und vierten Schicht zu optimierende Parameter.
1. Schicht: Zugehörigkeit zu den Fuzzy-Mengen
2. Schicht: Gewichte der Regeln durch Produktbildung
3. Schicht: Berechnung der normalisierten Gewichte
4. Schicht: Berechnung der Ergebnisse der einzelnen Regeln
5. Schicht: Endergebnis durch Summenbildung
258
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Anfis-Netz für Typ 3 Fuzzy-Kontroller
 Ai
 Bi
A1
B1
w1
 A2
f1  p1 x  q1 y  r1
 B2
A2
f 
B2
w1 f1  w2 f 2

w1  w2
w1 f1  w2 f 2
f 2  p2 x  q2 y  r2
w2
x
y
layer 1
layer 2
A1

x
layer 3
w1

layer 4
x
y
layer 5
w1
w1 f1
A2

w2 f 2
B1

y
B2

w2
w2
x
y
Abb.: Anfis-Netz für den Typ 1 Fuzzy-Kontroller mit 2 Regeln
Das Anfis-Netz für einen Typ 3 Fuzzy-Kontroller ist ein fünf Schichten umfassendes
Netz mit Shortcuts. Der Unterschied besteht darin, das in der 4. Schicht die
Ergebnisfunktionen von der Eingabe abhängen und nicht von den Gewichten. Falls
die Ergebnisfunktionen nur Konstanten sind, so ist das Anfis-Netz fast äquivalent mit
einem RBF-Netz.
259
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3.2.3.4.2.2 Lernregel für Anfis-Netze
Zur Anwendung kommen Backpropagation- bzw. Hybrid-Lernregel. Lernen mit der
Backpropagation-Lernregel ist langsam und kann in lokalen Minima festhängen. Eine
weitere Möglichkeit ist die Hybrid-Regel: eine Mischung aus Backpropagation-Regel
und der Lernregel durch den kleinsten quadratischen Schätzer.
Hybrid-Lernregel für Typ 3 Anfis Netze
Für Typ 3 Anfis-Netze ist die Hybrid-Lernregel gut geeignet, weil man das
Gesamtverhalten des Netzes als eine Linearkombination der Parameter aus der 4.
Schicht (Konsequenzparameter) beschreiben kann:
f 
w1
w2
f1 
f 2  w1 f1  w2 f 2
w1  w2
w1  w2
Für die Hybrid-Lernregel werden Parameter in 2 Arten aufgeteilt:
-
Prämissenparameter S1, die man durch das Backpropagationverfahren
optimiert.
Konsequenzparameter S2, die man durch die Methoden des kleinsten
quadratischen Schätzers bestimmt.:
Man führt dazu einen Forwardpass aus:
-
-
1. Für jedes Trainingspaar (x, output) berechnet man die Werte, so dass für das x gerade die
Funktion des Netzes Abhängigkeit der Werte von S2 entsteht. Da diese Funktion bzgl. der
Parameter bei festen Werten von S1 linear ist, erhält man 2 Matrizen A, B mit A  s  B
2. Hierfür berechnet man den kleinsten quadratischen Schätzer mit Hilfe von Pseudoinversen,
also einem Schätzer, der AS  B
2
minimiert. Das ergibt die optimierten Parameter von S2
Die Parameter von S1 werden durch einen Backwardpass und die übliche
Gradientenmethode bei festen Werten von S2 optimiert.
Hybrid-Lernregel für Typ 1 Anfis Netze
Man ersetzt die Ereignisfunktion der 4. Schicht durch stückweise lineare Funktionale
und mit denen wendet man die Hybrid-Lernregel an.
260
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
4. Konzept und Arbeitsweise genetischer Algorithmen
4.1 Evolution und Genetik
1. Lernprozeß Evolution
Die Natur hat es geschafft, aus Milliarden denkbarer Eiweißmoleküle gerade
diejenigen herauszufinden, die organisches Leben ermöglichen. Die Evolution hat
schließlich zur Entstehung der DNS (Desoxyribonucleinsäure) geführt, die allem
Leben (auf der Erde) als Bauplan zugrundeliegt. Die DNS eines Menschen enthält
etwa 3,8 Milliarden Nukleotidbasen105. Die Entwickling kann kein reiner Zufallsprozeß
gewesen sein. Evolution kann vielmehr nur durch einen kollektiven Lernprozeß
erklärt werden, wobei erfolgreiche Innovationen „gespeichert“ und erfolglose
vergessen werden.
Die Evolution stützt sich auf das Prinzip der natürlichen Selektion und die Vererbung
von Eigenschaften und Merkmalen. Unter Selektion versteht man das Fortbestehen
der Individuen, die am besten an die Umwelt angepaßt sind und das Aussterben der
schlechter angepaßten Individuen. Die stärkeren Individuen haben die Möglichkeit,
sich fortzupflanzen und ihre Eigenschaften an die nächste Generation
weiterzugeben.
2. Chromosomen und Gene
Chromosome sind Träger der Gene, der kompletten Erbinformation eines
Lebewesens. Die Chromosomen bestehen aus Nukleinsäuren und Proteinen. Die
wichtigste Nukleinsäure ist die DNS. Gene stellen bestimmte Abschnitte der DNS
dar. Am Aufbau der DNS sind 4 Basen beteiligt: Adenin (A), Cytosin (C), Guamin
(G), Thymin (T). Diese Basen bilden die Grundlage für die gesamte genetische
Information eines Lebewesens, die als Sequenz der Buchstaben eines genetischen
Alphabets A, C, G und T wie bspw. in „...-C-C-T-G-A-G-G-A-G-...“ notiert werden
kann. Das bezeichnet man als den sog. Genetischen Code, der als Programm
verstanden werden kann, das die Entwickling eines neuen Individuums festlegt.
3. Grundlegende Mechanismen der Vererbung
Es liegt bspw. das Chromosom g mit 10 Genen g1 bis g10 vor.
g1
g2
g3
g4
g5
g6
g7
g8
g9
g10
Abb.4.1-1: Chromsom mit 10 Genen
Jedes Gen ist durch seine Position im Chromosom bestimmt und kontrolliert eine
ganz bestimmte Eigenschaft bzw. ein bestimmtes Merkmal eines Lebewesens wie
bspw. seine Augenfarbe. So hat das Gen g4 bspw, den Wert „blau“.
105
Kettenglieder der DNS
261
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Die Gesamtheit der Gene g = (g1, g2, g3, g4, g5, g6, g7, g8, g9, g10) bezeichnet man als
den Genotyp des Individuums und meint damit das Erbbild. Das Individuum selbst,
der sog. Phänotyp, ist die konkrete Ausprägung der Merkmale. Der Phänotyp muß
sich im Kampf um Dasein behaupten.
Neue
Individuen
(bzw.
neue
Chromosomen)
entstehen
durch
Rekombinationsverfahren. Das vorherrschende Verfahren in der Natur ist die
Paarung, die zur Kreuzung der Erbinformation und damit zu neuen Ausprägungen
führt.
4.2 Prinzipielle Arbeitsweise genetischer Algorithmen
4.2.1 Arbeitsweise von genetischen Algorithmen
Zufällig erzeugte Lösungen des Suchraums der Problemstellung bilden die
Ausgangspopulation. Sie wird im Verlauf eines Genetischen Algorithmus durch einen
Evolutionsprozeß verbessert. Bei der Suche nach besseren Lösungen kombinieren
Genetische Algorithmen das Überleben der tauglichen Individuen einer Population
mit einem Austausch der genetischen Information zwischen den einzelnen
Individuen. Die Individuen werden mit einer ihrer relativen Tauglichkeit (Fitneß)
entsprechenden Wahrscheinlichkeit ausgewählt. Besonders taugliche Individuen
erhalten bevorzugt die Möglichkeit zur Weitergabe der Lösungsinformation („survival
of the fitest“). GA führen einen zufallsgesteuerten Suchprozeß durch, der durch die
Nutzung populationsspezifischer Eigenschaften gesteuert wird.
Der evolutionäre Such- und Optimierungsprozeß beruht auf 3 grundlegenden
Prinzipien: Auslese (Selektion), Veränderung (Rekombination, Mutation) und
Vervielfachung (Reproduktion) von Individuen. Die Grundprinzipien werden bei
genetischen Algorithmen durch spezielle „Genmanipulationen“ verwirklicht. Das
erfolgt natürlich nicht auf biologischen Chromosomen, sondern auf „Strings“, die bei
„GA“ für die Problemlösungen (Gesamtheit der Individuen) stehen. In der Regel sind
die Strings „binär“ kodiert, d.h. Jedem Gen einspricht ein Bitwert (Allel) 0 oder 1.
262
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Population zum Zeitpunkt t
Kreuzung (crossover)
Selektion
Mutation
Verdrängung
Population zum Zeitpunkt t + 1
Abb. 4.2-1: Prinipielle Arbeitsweise genetischer Allgorithmen
4.2.2 Struktur eines genetischen Algorithmus
Aus der allgemeinen Arbeitsweise eines genetischen Algorithmus ergibt sich die
folgende Struktur eines genetischen Algorithmus, die in zahlreichen Varianten
auftauchen kann:
Erzeuge eine Anfangspopulation von Individuen P := {p}
repeat
Bewerte jedes Individuum der Population P
Selektiere Individuen zur Reproduktion (Crossover)
Erzeuge neue Population P von Individuen
until
Abbruchkriterium
Gib Individuum pmax mit maximaler Fitneß aus
Ein genetischer Algorithmus setzt sich dann zusammen aus:
-
einer Kodierungsvorschrift für die Lösungskandidaten
einer Methode, eine Anfangspopulation zu erzeugen
eine Bewertungsfunktion (Fitneßfunktion) für die Individuen
einer Auswahlmethode auf der Grundlage der Fitneßfunktion
263
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Ein genetischer Algorithmus besteht weiter aus





genetischen Operatoren, die die Lösungskandidaten ändern
Mutation (zufällige Änderung einzelner Gene
Crosover – Rekombination von Chromosomen
Werten für die verschiedenen Parameter (z.B. Populationsgröße, Mutationswahrscheinlichkeit)
Einen Abbruchkriterium
eine festgelegte Anzahl von Generationen wurde berechnet
eine festgelegte Anzahl von Generationen lang gab es keine Veränderung
eine vorgegebene Mindestlösungsgüte wurde erreicht
4.3 Phasen eines genetischen Suchalgorithmus
4.3.1 Modellierung
Durch Bestimmen einer geeigneten Codierung werden Lösungen des Suchraums im
Rahmen einer geeigneten Abbildung über Zeichenketten (häufig Bitstrings)
modelliert. Die Strings, die zur Darstellung der zulässigen Lösungen gebildet werden,
sind die Genotypen einer Population. Die zulässigen Lösungen bezeichnet man als
Phänotypen. Ein Phänotyp stellt das äußere Erscheinungsbild eines Individuums
dar, das der Informationsgehalt des Genotyps durch Dekodierung bestimmt.
4.3.2 Konfigurierung
1. Genetische Operatoren
Elemetare genetische Operatoren sind:
1.1 Selektion
Sie besteht in der Auswahl von Individuen, gemessen anhand ihres
Tauglichkeitsgrads. Alle ausgewählten Individuen werden bei der Generierung von
Nachkommen berücksichtigt.
1.2 Crossover
Elternpaare werden zufällig aus ausgewählten Individuen gebildet und daraufhin
Nachkommen generiert, die eine genotypische Ähnlichkeit zu den jeweiligen Eltern
aufweisen. Die Ähnlichkeit der Individuen wird durch einen Informationsaustauch
zwischen den Genotypen der Eltern erreicht.
Aus 2 Genotypen werden wieder Kinder (Crossover) gebildet, die dann in eine neue
Population eingetragen werden. Die alte Population (Eltern-) bleibt unverändert.
Beim Crossover tauschen die Elterm Teile ihres Gen-Strings miteinander aus. Die
Stelle, ab der getauscht wird, wird durch Zufall ermittelt. Dazu wird die Zeichenkette
des einen Eltermteils an beliebiger Stelle getrennt. An der gleichen Stelle wird auch
die Zeichenkette des anderen Elternteils gespalten. Die 4 Teilstücke werden über
264
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Kreuz (Crossover) verbunden. Der vordere Teil des einen mit dem hinteren Teil des
anderen Strings. Die so erzeugten „Kinder“ werden dann in die Population der
Nachkommen eingetragen.
1.3 Mutation
Sie tritt nur „gelegentlich“ bei der Verarbeitung der Zeichenkette auf und bewirkt eine
kleine Veränderung des Genotyps. Der Zweck der Mutation besteht in der
Vermeidung einer vorzeitigen Spezialisierung der Individuen einer Population.
Die Mutation verändert willkürlich Gen-Strings. Startpopulationen werden mit dem
Zufallszahlengenerator gebildet. Es kann vorkommen, daß in der kompletten
Population kein Gen-String existiert, der einer vom Problem her vorgegebenen
Bedingung entspricht. Selektion und Crossover können Zeichenketten manipulieren,
nicht an entscheidender Stelle zugleich verändern. Eine zu häufige Mutation ist aber
schädlich, da sie ja auch „gute Strings“ zum Schlechten hin verändern kann. Daher
läßt man die Mutation mit nur einer geringen Wahrscheinlichkeit auftreten (z.B. 0.1%
aller Fortpflanzungen). Welches Gen des Gen-String geändert wird, bleibt dem Zufall
überlassen.
Nach Selektion, Crossover und Mutation besitzt die Nachkommen-Population zwei
neue Mitglieder. Da die Populationsgröße konstant bleiben muß, wird diese Kette
von Operatoren eines GA so oft durchgeführt, bis die neue Population vollständig mit
Kinder besetzt ist. Damit ist ein Iterationsschritt oder auch ein Generations-wechsel
beendet und die Eltern-Population wird nicht mehr benötigt. Die Nachkom-menPopulation wird zur Elternpopulation. Für jedes Element der Population wird wieder
die Fitneß ermittelt. Danach bildet man nach der beschriebenen Weise eine neue
Nachkommen-Population, etc.
Damit ergibt sich der folgende allgemeine Programmablaufplan eines genetischen
Algorithmus, die in zahlreichen Varianten auftauchen kann:
265
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Auswahl einer Ausgangspopulation
Wahl der Codierung
Ermittlung der Fitness der Individuen
Selektion
der
Eltern
Auswahl eines Individuums
NEIN
Matching-pool voll?
Auswahl eines oder mehrerer Eltern
Zeugung
der
Auswahl
und
Rekombination (Reproduktion)
Anwendung
Mutation
Crossover
Nachkommen
NEIN
Neue Generation voll?
NEIN
JA
Abbruchbedingung
erfüllt
Ende der Optimierung
Abb. 4.3-1: Prgrammablaufplan für genetische Algorithzmen
2. Optimierung mit genetischen Algorithmen
Genetische Algorithmen sollen im Raum zulässiger Lösungen diejenigen
herausfinden, die hinsichtlich einer gegebenen Zielfunktion die günstigsten
Eigenschaften besitzen. Die Suche nach dem Optimum führen genetische
Algorithmen in mehreren Schritten aus:
(1) Festlegen einer Zielfunktion
Sie ergibt sich direkt aus dem zu optimierenden Problem (Phänotyp des Problems).
Außerdem wird das Abbruchkriterium bestimmt: Entweder nach einer festzulegenden
anzahl von Iterationsschritten (Generationen) oder nach dem Auffinden einer
zufriedenstellenden Lösung.
(2) Kodierung und Festlegung des genetischen Suchraums
Genetische Algorithmen arbeiten mit einer Poulation von n Individuen. Zu jedem
Individuum sind zulässige Lösungswerte für die Variablen des Optimierungsproblems kodiert. Jedes Individuum besteht aus n Genen (Vektor mit n Komponenten). Bei genetischen Algorithmen wird häufig binär kodiert, d.h. jedem Gen ein
Bitwert (Allel) 0 oder 1 zugewiesen.
(3) Erzeugen einer Startpopulation binär codierter Lösungen auf zufällige Weise
Die Ausgangssituation wird durch eine mit dem Zufallsgenerator benötigte Anzahl
von Gen-Strings festgelegt.
266
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
(4) Bewertung der Überlebensfähigkeit der einzelnen Individuen unter den
gegebenen Umweltbedungungen
Alle Nebenbedingungen und die Zielfunktion müssen in der Fitneßfunktion
berücksichtigt werden.
(5) Selektion zweier Elternindividuen mit fitneßproportionaler Wahrscheinlichkeit
Die Selektionswahrscheinlichkeit eines Individuums ergibt sich aus dem Verhältnis
des individuellen Fitneßwerts zur Summe aller Fitneßwerte einer Generation. Die
Auswahl realisiert das Prinzip „Survival of the fittest“. Individuen mit einem besseren
Fitneßfunktionswert erhalten eine größere Wahrscheinlichkeit Nachkommen zu
erzeugen als weniger geeignete Individuen.
Die Selektion bestimmt, welche Mitglieder der Population (Startpopulation) sich
fortpflanzen dürfen. Zur Vermeidung von Inzucht ist aber auch weniger geeigneten
Mitgliedern (im bescheidenen Maße) die Fortpflanzung erlaubt. Eine gute Selektion
erreicht man mit dem Roulette-Verfahren. Dieses bewirkt, daß die
Wahrscheinlichkeit mit der ein Genstring bei der Selektion ausgewählt wird,
proportional zu seiner Güte ist. Die Anzahl der Fächer im Roulette-Rad entspricht der
Anzahl seiner Genotypen in einer Population. Der Genotyp mit höchster Qualität
bekommt das größte Feld zugewiesen. Die Aufteilung geht abwärts bis zum
schlechtesten Gen-String, der das kleinste Feld zugewiesen bekommt.
Markierung
Genotyp 5
Genotyp 4
Genotyp 1
Genotyp 2
Genotyp 6
Genotyp 3
Auswahl eines Individuums:
-
Drehe Glücksrad
Wähle Chromosom dessen Sektor an der Markierung liegt
Auswahl der Zwischenpopulation:
-
Wiederhole die Auswahl so oft, wie es Individuen in der Population gibt.
Abb. 4.3-2: Roulette-Rad
Je höher die Tauglichkeit eines Lebewesens ist, desto breiter ist das Fach und umso
wahrscheinlicher ist es, daß die Roulette-Kugel in einem solchen Fach hängenbleibt.
Alle Tauglichkeitswerte werden aufsummiert und daraus der mittlere Gütewert
ermittelt:
267
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
f rel ( s) 
f abs ( s)
ist die Ausfallwahrscheinlichkeit eines Individuums (sog.
s 'p(t ) f abs (s' )
fitnessproportionale Selektion106)
Ein guten Lebewesen (Genotyp) erzeugt einen Gütewert über dem Mittelwert. Die
Gesamtgüte geteilt durch den Gütewert eines Genotyps ergibt dessen
Wahrscheinlichkeit. Mit einem Zufallszahlengenerator kann dann die Selektion für
einen Genotyp vorgenommen werden.
Die daraus resultierenden Eltern werden nach Fitness im folgenden Generationsschritt benutzt, alle übrigen werden vergessen. Häufig verwendet man auch die
folgende Form der Selektion (mit dem Parameter r, 0  r  population s _ groesse und
p c , 0  pc  1 ):
-
-
Wähle aus der Population p(t) zufällig (aber unter Berücksichtigung der Fitneß) r
Chromosomen (mit Zurücklegen)
Bestimme für jedes für jedes dieser r Chromosomen, ob es am Crossover teilnimmt
(Wahrscheinlichkeit p c ) oder mutiert wird (Wahrscheinlichkeit 1  p c ) und wende die
genetischen Operatoren an.
Wähle aus p (t ) zufällig (aber unter Berücksichtigung der Fitneß populations _ groesse  r
Chromosomen (ohne Zurücklegen)
Diese populations _ groesse  r Chromosomen werden unverändert übernommen
(6) Crossover und Mutation
Mit der vorher festgelegten Crossover-Rate (Rekombinatinswahrscheinlichkeit,
empfohlen wird ein Wert zwischen 0.6 und 1) wird bestimmt, ob überhaupt ein
Crossover stattfinden soll. Dann wird gleichverteilt-zufällig ein für beide Elternindividuen identischer Crossover-Punkt bestimmt. Durch Tausch der Teilstücke
werden Nachkommen erzeugt.
Gene werden nur mit einer sehr geringen Wahrscheinlichkeit (Mutationsrate, beliebte
Werte sind 0.001 bzw. 0.01) invertiert. Die Mutation soll dem frühzeitigen
Konvergieren des genetischen Algorithmus entgegenwirken.
(7) Wiederholung der Schritte (5) und (6) bis die Nachfolgegeneration die Größe der
Elterngeneration erreicht hat bzw. der Schritte ab Schritt (4), bis das
Abbruchkriterium erfüllt ist. Anderenfalls endet der Algorithmus und die Ergebnisse
werden ausgegeben.
In der Regel wird die Optimierung nach einer vorher festgelegten, als ausreichend
angesehen Anzahl von Generationen abgebrochen. Wählt man aus der letzten
Population den Genotyp aus, der die höchste Güte besitzt, hat man meistens ein
brauchbares Ergebnis der Optimierung. Noch besser ist es, bei jeder erzeugten
Population den jeweils besten Genotyp herauszusuchen und festzuhalten. Wird in
einer späteren Generation eine besserer Genotyp gefunden, so wird dieser
gespeichert. Eine Alternative besteht darin, sich ebenfalls den besten Genotyp einer
Population zu merken und über eine bestimmte Anzahl von Populationen zu
beobachten. Stellt man dabei keine Verbesserung des jeweiligen besten Genstrings
fest, dann kann die Optimierung beendet werden.
106
Die absolute Fitness
f abs (s) darf in diesem Fall nicht negativ sein, ggf. ist ein positiver Wert zu addieren
und negative Werte sind Null zu setzen.
Die Fitneß muß zu maximieren sein. (Sonst würden schlechte Individuen mit hoher Wahrscheinlichkeit gewählt).
268
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
3. Einfacher genetischer Algorithmus (Simple GA)
begin
Festlegen der Zielfunktion
Bestimmen eines Abbruchkriteriums
Codierung
Festelegen der genetischen Operationen
Erzeugen der Startpopulation binär codierter Lösungen auf zufällige Weise
DO
DO
Selektion zweier Elternindividuen mit fitneßproportionaler
Wahrscheinlichkeit
Crossover mit Wahrscheinlichkeit in Höher der Crossover-Rate
Mutation einzelner Bits der so entstandenen Nachkommen mit
Wahrscheinlichkeit in Höhe der Mutationsrate
Übername beider Nachkommen in die Nachfolgegeneration
Aktuelle Generation = Nachfolgegeneration
WHILE Nachfolgegeneration unvollständig
WHILE Abbruchkriterium noch nicht erfüllt
end
4.3.3 Die Realisierungsphase
Sie umfaßt alle Arbeiten zur Umsetzung des Entwurfs in ein lauffähiges
Optimierungsverfahren (Implementierung, Bestimmen von Werten für externe
Parameter).
Bsp.: Bestimme das Maximum der Funktion f(x)=x2 für x-Werte, die zwischen 0 und
31 liegen.
1. Codierung des Eingabebereichs 0..31 über einen binären String (durch eine 5 Bit
umfassende Binärzahl).
2. Zufällige Auswahl einer Ausgangspopulation.
3. Berechnung der Fitness.
4. Aus dem Roulette-Rad werden die aktuellen Elternpaare ermittelt, die die neue
Population erzeugen sollen.
Zeichenkette
Nr.
1
2
3
4
Summe
Durchschnitt
Max
AnfangsPopulation
0 1 1 0 1
1 1 0 0 0
0 1 0 0 0
1 0 0 1 1
x-Wert
f(x)=x2
13
24
8
19
169
576
64
361
1170
293
576
Es wurden ermittelt:
„String 1“ wird einmal kopiert
„String 4“ wird einmal kopiert
„String 2“ wird zweimal kopiert
„String 3“ wird überhaupt nicht kopiert
5. Crossover
a) Die Zeichenketten werden zur Paarung zufällig ausgewählt
b) Ausgewählte Paare werden an zufällig ausgewählten Punkten gepaart.
269
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Im vorliegenden Bsp. werden String 1 und String 2 an Punkt 4 gekreuzt, String
3 und String 4 an Punkt 2.
6. Mutation
Die Wahrscheinlichkeit für eine Mutation soll hier 0.001 sein. Über die 20
Bitpositionen ergibt das einen Erwartungswert vom 20 * 0.001 = 0.02 bits für eine
Mutation währen einer Generationenfolge. Hier würde keine Bitposition von einer
Änderung betroffen sein.
7. Test der neuen Population
Population
nach der Reproduktion
0 1 1 0.1
1 1 0 0.0
1 1.0 0 0
1 0.0 1 1
Partner
(zufällig
ausgew.)
2
1
4
3
Crossover
Punkt
Neue Population
x-Wert
f(x)=x2
169
576
64
361
0
1
1
1
12
25
27
16
144
625
729
256
1754
439
729
1
1
1
0
1
0
0
0
0
0
1
0
0
1
1
0
Implementierung107:
#include
#include
#include
#include
<stdlib.h>
<stdio.h>
<time.h>
<math.h>
#define random(num) (rand()%(num))
#define randomize() srand((unsigned)time(NULL))
#define
#define
#define
#define
#define
POPULATION_SIZE
CHROM_LENGTH
PCROSS
PMUT
MAX_GEN
10
5
0.6
0.5
50
struct population
{
int value;
unsigned char string[CHROM_LENGTH];
unsigned int fitness;
};
struct population pool [POPULATION_SIZE];
struct population new_pool[POPULATION_SIZE];
int selected[POPULATION_SIZE];
int generations;
// select
int select(double sum_fitness)
{
double r, parsum; int i;
parsum = 0;
r = (double)(rand() % (int)sum_fitness);
for (i = 0; i < POPULATION_SIZE, parsum <= r; i++)
parsum += pool[i].fitness;
return(-i);
}
107
max.CPP
270
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
int flip(double prob)
{
double i;
i = ((double)rand()) / RAND_MAX;
if ((prob == 1.0) || (i < prob))
return (1);
else
return (0);
}
// crossover
void crossover(int parent1, int parent2, int child1, int child2)
{
int site; int i;
if (flip(PCROSS))
site = random(CHROM_LENGTH);
else
site = CHROM_LENGTH - 1;
for (i = 0; i < CHROM_LENGTH; i++)
{
if ((i <= site) || (site == 0))
{
new_pool[child1].string[i] = pool[parent1].string[i];
new_pool[child2].string[i] = pool[parent2].string[i];
}
else
{
new_pool[child1].string[i] = pool[parent2].string[i];
new_pool[child2].string[i] = pool[parent1].string[i];
}
}
}
// mutation
void mutation()
{
for (int i = 0; i < POPULATION_SIZE; i++)
{
for (int j = 0; j < CHROM_LENGTH; j++)
if (flip(PMUT))
pool[i].string[j] = ~new_pool[i].string[j] & 0x01;
else
pool[i].string[j] = new_pool[i].string[j] & 0x01;
}
}
// evaluate
int evaluate(int value)
{
return /*(pow((double) value, 2))*/ value * value;
}
// encode
// (kodiert einen Integer-Wert in eine binaere Zeichenkette)
void encode(int index, int value)
{
for (int i = 0; i < CHROM_LENGTH; i++)
pool[index].string[CHROM_LENGTH - 1 - i] = (value >> i) & 0x01;
}
// decode
// dekodiert eine binaere Zeichenkette in eine Ganzzahl
271
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
int decode(int index)
{
int value = 0;
for (int i = 0; i < CHROM_LENGTH; i++)
value += (int)pow(2.0,(double) i) *
pool[index].string[CHROM_LENGTH - 1 - i];
return (value);
}
// initialize_population
// (erzeugt und initialisiert eine Population
void initialize_population()
{
randomize();
for (int i = 0; i < POPULATION_SIZE; i++)
encode(i,random(2^CHROM_LENGTH));
}
void statistics()
{
int i, j;
printf("\n; Generation: %d\n;SelectedStrings\n;",generations);
for (i = 0; i < POPULATION_SIZE; i++)
printf("%d", selected[i]);
printf("\n");
printf("\nX\tf(x)\tNew_String\tX");
for (i = 0; i < POPULATION_SIZE; i++)
{
printf("\n%d\t%d\t", pool[i].value, pool[i].fitness);
for (j = 0; j < CHROM_LENGTH; j++)
printf("%d", pool[i].string[j]);
printf("\t\t%d",decode(i));
}
}
void main(void)
{
int i;
double sum_fitness, avg_fitness, old_avg_fitness;
generations = 1;
avg_fitness = 1;
initialize_population();
do
{
if (avg_fitness <= 0.0) break;
old_avg_fitness = avg_fitness;
sum_fitness
= 0;
// fitness evaluation
for (i=0; i < POPULATION_SIZE; i++)
{
pool[i].value
= decode(i);
pool[i].fitness = evaluate(pool[i].value);
sum_fitness
+= pool[i].fitness;
}
avg_fitness = sum_fitness / POPULATION_SIZE;
for (i = 0; i < POPULATION_SIZE; i++)
selected[i] = select(sum_fitness);
for (i = 0; i < POPULATION_SIZE; i = i + 2)
crossover(selected[i], selected[i+1],i,i+1);
mutation();
statistics();
printf("\nimprovement: %f\n", avg_fitness / old_avg_fitness);
}
while ((++generations < MAX_GEN) /*&& (avg_fitness >= 0.0) */
&& ( ((avg_fitness / old_avg_fitness) > 1.005) ||
272
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
((avg_fitness / old_avg_fitness) < 1.0) ) );
system("Pause");
}
Nach 50 Generationen zeigt sich folgende Ausgabe:
Abb. Resultat nach 50 Generationen
4.3.4 Verfahrensbewertung bzw. Verfahrensverbesserung
Im Anschluß an eine Realisierung des Algorithmus sollte eine Verfahrensbewertung
erfolgen
sowie
eine
Verfahrensverbesserung,
die
sich
von
einer
Verfahrenserweiterung bis hin zur erneuten Abarbeitung aller Phasen der
Entwicklung eines GA erstrecken kann.
4.3.5 Güte eines genetischen Algorithmus
Zu Beurteilung eines Genetischen Algorithmus betrachtet man meist sein
Konvergenzverhalten
sowie
seine
-geschwindigkeit.
Bezüglich
des
Konvergenzverhaltens vergleicht man die Qualität, also die Zielfunktionswerte, der
von einen Genetischen Algorithmus berechneten Lösungen mit denen anderer
Verfahren. Reicht zur Lösung des Problems die Erzeugung eines guten Individuums,
so wählt man natürlich das beste Individuum der Population als Vergleichswert. Ist
man jedoch an einer guten Gesamtpopulation interessiert, so vergleicht man die
mittlere Fitneß aller Mitglieder der Population mit der bereits bekannten Lösung. Mit
dem Begriff der Konvergenzgeschwindigkeit wird bewertet, wie schnell, das heißt
nach Ablauf wie vieler Generationen, Lösungen bestimmter Qualität hervorgebracht
werden. Zur Darstellung der Konvergenzgeschwindigkeit werden Diagramme
benutzt, in denen die erreichte Lösungsqualität in Abhängigkeit der Generationen
dargestellt wird.
Insgesamt scheint die Modellierung des Evolutionsprozesses ein gelungener
Kompromiß zwischen rechenzeitintensiven Verfahren, die das Auffinden von
optimalen Lösungen garantieren, und einfachen deterministischen Heuristiken zu
sein, die zwar sehr schnell, aber leider häufig schlechte Lösungen produzieren.
273
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Durch die Festlegung der Anzahl der Generationen kann sich der Benutzer eines
Genetischen Algorithmus zwischen beiden Extremen entscheiden. Erlaubt er nur
eine kleine Anzahl von Generationen, werden nur relativ schlechte Lösungen
gefunden, während eine große Generationenzahl das Auffinden fast optimaler
Lösungen wahrscheinlich macht. Die stochastische Beeinflussung der
deterministischen Operatoren eines Genetischen Algorithmus erlaubt die
Überwindung lokaler Optima in Suchraum, und die Organisation der Suche mittels
einer Population von Punkten im Suchraum (und nicht eines einzelnen Punktes)
verkleinert die Gefahr, daß keiner der Suchpunkte in der Lage ist, einen
verbesserten Nachkommen zu produzieren. Genetische Algorithmen, so scheint es,
sind auf dem besten Wege, zumindest die Bearbeitung der großen Klasse der
kombinatorischen Optimierungsprobleme zu (r)evolutionieren.
4.5 Anwendungen
4.5.1 Ein genetischer Algorithmus für das Problem des Handlungsreisenden
1. Aufgabenstellung
Das Travelling-Salesman-Problem - ein Reisender sucht die kürzeste Rundtour
durch verschiedene Städte - läßt sich zwar ganz einfach beschreiben und
anschaulich darstellen, doch ist es nach wie vor Forschungsgegenstand ganzer
Expertengruppen. Der Grund hierfür liegt auf der Hand: Bis heute ist kein
Algorithmus bekannt, der weniger als exponentiellen Aufwand benötigt, um die
optimale Rundreise zu ermitteln. In gewisser Hinsicht kann das TSP sogar als
klassisches
Grundproblem
der
kombinatorischen
Optimierung
(z.B.
Reihenfolgenprobleme) angesehen werden, was den repräsentativen Umgang mit
Lösungsalgorithmen,
gerade
auf
Hinblick auf
komplizierter gestaltete
Alltagsprobleme, um so interessanter macht.
2. Repräsentation des Lösungsraums und Crossover-Operatoren
Die Repräsentation des Lösungsraums erfolgt durch eine Zeichenkette, die die
Identifikation zu den Städten der Rundreise (Knotennummern) angibt, z.B.:
1 2 3 4 5 6 7 8 9 10
In dieser Zeichenkette liegt eine aufsteigende Ordnung der Knotennummern zu
bspw. 10 Städten vor, die in der Regeln nicht die kürzeste Rundreise repräsentiert.
Zur Bildung geeigneter Kandidaten füe eine kürzeste Rundreise stehen eine Reihe
von Varianten des Crossover bereit bereit (parallel matched crossover (PMX), order
crossover (OX) und cycle crossover (CX))108.
Beim CX-Operator wird bspw. bezogen auf 2 zu kombinierende Touren
108
vgl. David E. Goldberg: Genetic Algorithms in Search, Optimization, and Machine Learning, AddisonWesley Publishing Company, Reading / Massachusetts, ...
274
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
A = 9 8 2 1 7 4 5 10 6 3
B = 1 2 3 4 5 6 7 8 9 10
folgendes Auswahlverfahren getroffen:
Gestartet wird in A von links und dann die folgende Stadt vom ersten Elternteil
ausgewählt:
A‘ = 9 - - - - - - - - Die Auswahl der 9 erfordert die Wahl von 1 aus dem zweiten Elternteil und bestimmt
die „1“ an Postion 4 in A‘:
A‘ = 9 - - 1 - - - - - B = 1 2 3 4 5 6 7 8 9 10
Unter der 1 in A‘ steht 4, in A wird als nächste Größe 4 ausgesucht:
A‘ = 9 - - 1 - 4 - - - B = 1 2 3 4 5 6 7 8 9 10
Unter der 4 in A‘ steht eine 6, sie wird in A‘ als nächste Größe bestimmt:
A‘ = 9 - - 1 - 4 - - 6 B = 1 2 3 4 5 6 7 8 9 10
Jetzt käme 9 an die Reihe, das führt aber zu einem Kurzzyklus. Deshalb werden die
restlichen Stringpositionen einfach getauscht:
A‘ = 9 2 3 1 5 4 7 8 6 10
3. Selektion
Neben dem Crossover beeinflußt der Selektionsoperator das Verhalten eines
Genetischen Algorithmus wesentlich. Zu diesem Zweck werden Individuen hoher
Qualität häufiger zur Rekombination ausgewählt. Sie sollen öfter Nachkommen
generieren, die deren gute Eigenschaften erben. Man sagt auch, daß die Population
durch die Selektion einem Lernprozeß unterworfen wird, da mit zunehmender
Generationenzahl der Anteil der qualitativ guten Individuen ansteigt. Aber Vorsicht:
Eine zu häufige Wahl desselben Individuums bewirkt eine schnelle Durchsetzung der
gesamte Population mit dem genetischen Material nur eines Individuums. Dieses
kommt in etwa dem Effekt der Inzucht gleich: Durch den Verlust der genetischen
Vielfalt innerhalb einer Population wird eine Qualitätssteigerung durch die Evolution
unmöglich. Die Population stagniert dann häufig in einem schlechten lokalen
Minimum. Außerdem sollte berechnet werden, daß auchqualitativ schlechte
Individuen genetisches Material enthalten können, welches beim Crossover mit
guten Lösungen zu Evolutionsschüben führt. Gerade die Tatsache, daß auch
schlechte Individuen unverzichtbar für die evolutionäre Entwicklung einer Population
sind, ist von vielen Autoren Genetischer Algorithmen beobachtet worden.
275
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Zum Schutz vor diesen Problemen werden nur Kinder in die Population
aufgenommen, die sich von der Elternpopulation durch mindestens ein Merkmal
unterscheiden. Der Fairneß halber werden aber trotzdem Nachkommen einer
Generation bevorzugt, die die gleichen Merkmale haben wie die Eltern, um eine
gewisse Dynamik zu gewährleisten und den "Circle of Life" nachzubilden. Damit
nicht alle Individuen miteinander verglichen werden müssen, wird angenommen, daß
Lösungen mit verschiedener Fitneß auch verschiedene Gencodes besitzen.
4. Fitneß
Allgemein wird unter Fitneß die Anpassung von Individuen an ihre Umwelt
verstanden. Klar ist, daß zur Lösung von kombinatorischen Optimierungsaufgaben
Individuen gefragt sind, deren Zielfunktionswert - im Beispiel die Länge der
zurückgelegten Strecke - optimal ist. Hier bietet es sich an, eine minimale Fitneß als
erstrebenswert zu erachten, da die Länge der gefahrenen Rundreise ein exzellenter
Repräsentant dafür ist.
5. Applet mit einem genetischen Algorithmus zum Rundreiseproblem
http://fbim.fh-regensburg.de/~saj39122/dkst/Index.htm
4.5.2 Ein genetischer Algorithmus für das Packproblem
1. Aufgabenstellung109
Ein Kasten (Rechteck) ist so mit einer vorgegebenen Anzahl von Kästchen
(Rechtecken) aufzufüllen, daß die Stapeldichte möglichst groß, der Stapel möglichst
klein ist.
2. Problembeschreibung
Mathematiker reihen diese Probleme in die Klasse der kombinatorischen
Optimierungsprobleme. Sie faßt Aufgaben zusammen, deren Lösung das
Durchsuchen eines riesigen, vordefinierten Suchraums erfordert. Gesucht wird nach
Lösungen, die bzgl. einer Zielfunktion besonders niedere oder hohe Werte liefern
(z.B. TSP-Problem110). Beim Packproblem ist das Ziel: Minimierung der Stapelhöhe.
Zunächst ist der Suchraum, in dem dieses Ziel erreicht werden soll, „unendlich“ groß:
Man kann, wenn irgendwo nicht zu füllende Lücken auftreten, Bausteine beliebig
nach links oder rechts, unten oder oben verschieben. Verlangt man aber, daß in
einer zulässigen Lösung keines der Rechtecke im Behälter nach links oder nach
unten verschoben werden kann, ohne ein anderes Rechteck oder den Rand des
Behälters zu überlappen, so wird der Suchraum endlich. Diese Forderung soll als
109
Das Packproblem wurde beschrieben (einschl. Lösungsangaben in Pseudocode-Darstellung) in: mc, Mai
1991. Alle Angaben zum Algorithmus wurden aus dieser Quelle übernommen. Hier wurde der
Lösungsalgorithmus neu in objektorientierter Form überführt und als Java-Applet bereitgestellt.
110 vgl. 4.4.1
276
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
BL-Bedingung (BL = bottom/left) bezeichne werden. Da ein Rechteck flach oder
stehend gestapelt werden kann (Schrägstellungen sind ausgeschlossen), gibt es bei
m unterscheidbaren Rechtecken 2 m  m! Möglichkeiten, die Rechtecke zu ordnen.
3. Codierung111
Am Anfang jeder Ausprägung eines Genetischen Algorithmus auf ein konkretes
Problem steht die Frage nach eine geeigneten Codierung. Dieser Codierung sollte so
gewählt werden, das sie eine Übertragung von Erbgut während des CrossoverProzesses erlaubt. Die codierte Version einer möglichen Lösung heißt
chromosomale Darstellung oder Genotyp, seine äußere Erscheinung - hier also das
Packmuster - bezeichnet man als Phänotyp.
Was aber sind wesentliche Merkmale eines guten Packmusters, die an
nachfolgende Generationen vererbt werden sollen? Sicher nicht die absoluten
Positionen aller Rechtecke, die man erhält, wenn man ein Koordinatensystem mit
seinem Ursprung in die linke untere Ecke des Behälters legt. Deshalb nicht, da jedes
Packmuster wenigstens drei symmetrische Muster besitzt, deren Koordinaten sich in
der Regel stark unterscheiden. Symmetrische Packmuster können durch eine
geeignete Wahl von Spiegelachsen aus einem ebenso guten Muster erzeugt
werden. Jede dieser Spiegelungen läßt den Wert der Zielfunktion unverändert; sie
kann aber ein anschließendes Verschieben von Rechtecken erfordern, um die BLBedingung sicherzustellen. Auf Grund der nicht eindeutigen Positionsbeschreibung
durch absolute Koordinaten erschien eine Codierung durch relative Koordinaten der
Rechtecke zueinander sinnvoller. Dabei versteht man unter der relativen Position
eines Rechtecks seine Lage bezogen auf die anderer Rechtecke im Packmuster,
also zum Beispiel rechts oder oberhalb eines anderen. Diese Beschreibung ist
aufgrund der oben erwähnten BL-Bedingung sinnvoll und kann durch einen
gerichteten Graphen erfolgen. Jedes zu packende Rechteck ri erhält genau einen
Knoten zugewiesen, die als beschriftete Kreise dargestellt werden. Die Beschriftung
eines Knotens ist zweigeteilt: Sie besteht zum einen aus seiner Identifikation r i, sie
gibt andereseits aber auch die Orientierung des Rechtecks an. Liegt die längere
Seite parallel zu y-Achse, bewirkt dies einen  -Eintrag im Knoten, anderenfalls
einen  -Eintrag.
Unter Verwendung von Kanten können zwischen je zwei Knoten Beziehungen
hergestellt werden, etwa folgende: Grenzt ein Rechteck rj unmittelbar, das heißt
ohne daß ein Freiraum oder ein anderes Rechteck dazwischenliegt, rechts an ein
Rechteck rj, so führt eine gerichtete, mit r beschriftete Kante vom Knoten r i zu rj. Der
Knoten ri wird auch als Vater von rj, rj als Sohn von ri bezeichnet. Analog, liegt das
Rechteck rj unmittelbar oberhalb von ri, so wird der Knoten ri mit rj über eine mit o
beschriftete Kante verbunden.
Dabei darf zu genetischen Codierung nur noch genau eine Kante in jeden
hineinführen. Ausnahme ist die Wurzel, also der Knoten, der keine Vorgänger besitzt
und das Rechteck in der linken unteren Ecke des Behälters repräsentiert.
Desweiteren darf aus jedem Knoten maximal je eine o-Kante und eine r-Kante
hinausführen. Ein derartiger Graph wird auch Baum genannt. Bezogen auf das
Beispiel aus Abb. 4.4.1 bedeutet diese Einschränkungen, daß r5 entweder als oberer
Sohn von r3 oder als rechter Sohn von r4 vermerkt werden kann. Die oben erwähnte
111
Alle Angaben zur Codierung sind übernommen aus: Elegant tiefstapeln von Berthold Kröger in mc, Mai
1991, S. 72 - 88
277
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Ein-Kanten-Regelung legt die Position eines Rechtecks allerdings in nur einer
Dimension, entweder der Breite oder der Höhe, fest. Ist, wie in Abb. 4.4-2, r5 als
rechte Sohn von r4 deklariert, so ist damit zunächst nur eine Aussage über den
Abstand von r5 zum linken Rand des Behälters, nicht jedoch über seine Höhe
getroffen. Die Fixierung der jeweils offenen Dimension erfolgt aus der Erfüllung der
BL-Bedingung, also durch Verschiebung des Rechtecks entweder nach links oder
nach unten. Die Entscheidungskonflikte werden in unserer chromosomalen
Darstellung dadurch beigelegt, daß jeder Knoten eine Priorität erhält. Liegt ein
Konfliktfall vor, in dem mehrere Rechtecke gepackt werden können, so entscheidet
die höchste Priorität über die Reihenfolge. Abb. 4.4-2 zeigt die kompletten
chromosomalen Darstellungen einschließlich der Prioritäten für die in Abb. 4.4-1
dargestellten Packmuster. So legt die linke chromosomale Darstellung in Abb. 4.4-2
fest, daß die Rechtecke in der Reihenfolge r1 - r2 - r6 - r5 - r3 - r4 an die durch den
Graphen festgelegten Positionen gepackt werden.
Abb. 4.4-1:
Abb. 4.4-2:
Ein Nachteil dieser Codierungsvorschrift soll hier aber auch nicht verschwiegen
werden. Betrachtet man die chromosomalen Darstellungen aus Abb. 4.4-3, so kann
allein in Kenntnis der Codierungen nicht entschieden werden, ob diese
Packvorschrift ein zulässiges Packmuster beschreibt oder ob nicht doch
irgendwelche Unzulässigkeiten (Überlappungen) auftreten. Außerdem erlaubt der
Genotyp keine unmittelbaren Schlüsse auf die Qualität des beschriebenen
Packmusters, also eine Höhe im Behälter. Eine solche Zulässigkeit- und
Qualitätsanalyse erfordert jeweils die Decodierung in den zugehörigen Phänotyp,
was natürlich recht zeitintensiv werden kann. Hat man die genetische Beschreibung
der Probleminstanzen gefunden, ist man bei der Entwicklung eines genetischen
Algorithmus zwar den entscheidenen Schritt vorangekommen, am Ziel ist man in der
Regel aber noch nicht.
Ziel jedes Genetischen Algorithmus zur Lösung eines kombinatorischen
Optimierungsproblems muß es sein, Individuen zu erzeugen, die einen möglichst
nahe am Optimum liegenden Zielfunktionswert haben deren Fitneß also maximal ist.
Um die Laufzeit des Algorithmus zu minimieren, soll dieses Vorhaben erreicht
werden, indem die Suche auf die vielversprechendsten Teile des Suchraumes
konzentriert wird. Diese Beschränkung ist auch der Grund dafür, daß Genetische
Algorithmen nicht immer die absolut beste Lösung aus dem Suchraum finden oder
die Existenz einer noch besseren Lösung nicht ausgeschlossen werden kann. Um
die Qualität der generierten Individuen zu optimieren, um also möglichst geeignete
278
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Wege im Gebirge des Suchraums zu beschreiten, werden von einem evolutionären
Algorithmus die Individuen innerhalb einer Population den genetischen Operatoren
Mutation, Crossover und Selection unterworfen.
4. Operationen112
Mutation und Crossover sind konstruktive Operatoren, die bestehende Individuen
modifizieren und neue Punkte im Suchraum, spricht Packmuster, generieren. Die
Selektion ist ein strategischer Operator, der über die Zusammensetzung der
Populationen entscheidet. Der Mutationsoperator dient dazu, Erbgut, welches von
einem Elternteil auf den Nachkommen übertragen wird, zufällig zu verändern.
Bezogen auf das Packproblem beschreibt die Mutation einen wenig effizienten, aber
sehr aufwendigen Operator.
Der wirkungsvollste Operator eines Genetischen Algorithmus ist das Crossover.
Diese Operator modelliert die Fortpflanzung. Zwei ausgewählte Individuen, der Vater
Fv und die Mutter Fm erzeugen einen Nachkommen W. Hierzu wird ein Teil des
Erbgutes des Vaters mit dem der Mutter kombiniert, in der Absicht, gute
Eigenschaften der Eltern auf die Nachkommen zu übertragen und damit in
Punktraum die Punkte zu erzeugen, die nahe an denen der Eltern liegen. In dem
vorliegenden Algorithmus wird zur Erzeugung eines Nachkommen W mittels
Crossover zweier Eltern zunächst das vom Vater Fv übertragene Erbgut festgestellt.
Dazu wird in der Baumcodierung des Vaters ein Teilbaum T s zufällig bestimmt. Es
wird außerdem verlangt, daß der Teilbaum seiner umliegenden Rechtecke beraubt
noch zulässig gepackt werden kann. Ein solcher Teilbaum kann immer gefunden
werden; schlimmstenfalls genügt die Wahl eines hinreichend großen Teilbaums
ausgehend von der Wurzel des Vaters allen Voraussetzungen. Hat man einen
zulässigen Teilbaum ausfindig gemacht, wird er an den Nachkommen übertragen,
wobei die Orientierung und die Prioritäten aller Knoten des Teilbaums erhalten
bleiben. Aufgrund der Einpflanzung dient die Wurzel vom T s auch im Nachkommen
als Wurzel. Allein durch die Knoten von Ts beschreibt der Nachkomme in der Regel
noch keinen vollständigen Phänotyp, da noch nicht alle Rechtecke berücksichtigt
worden sind. Zur Komplettierung des Nachkommen wird auch genetisches Material
der Mutter verwendet. Dazu durchläuft man deren Knoten. Ist der gerade betrachtete
Knoten bereits mit Ts an den Nachkommen übergeben worden, bleibt nichts weiter
zu tun. Wenn der aktuelle Knoten jedoch noch nicht im Nachkommen erhalten ist,
wird die Codierung des Nachkommen entsprechend erweitert, was dem einfügen
eines Rechtecks in das unvollständige Packmuster entspricht. Zur Minimierung der
Packhöhe sollte natürlich jede Einfügung eines Rechtecks möglichst tief im Behälter
erfolgen. Die Arbeitsweise der Crossover-Operators wird im Bild 3 an einem Beispiel
erläutert.
Nach Vervollständigung der Kantenmenge E w des Nachkommen erhebt sich jetzt
die Frage, wie die Orientierungen und die Prioritäten des Nachkommen generiert
werden. Die Bestimmung der Orientierung ist einfach, die Festlegung der Prioritäten
etwas trickreich.
Die Orientierung der Rechtecke wird durch die Eltern festgelegt. Alle Rechtecke, die
mit dem Teilbaum in den Nachkommen übertragen wurden, behalten ihren dortigen
Eintrag bei, genau so wie die Knoten, die von den Mutter an den Nachkommen
vererbt wurden. Diejenige Knoten, die mit T s nach W kommen, behalten auch ihre
112
vgl. Berthold Kröger: Elegant tiefstapeln in mc, 1991, S. 72-88
279
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Prioritäten. Doch, alle nachfolgend von der Mutter in den Nachkommen kopierten
Knoten erhalten bei ihrer Einfügung neue Prioritäten, die kleiner sind als alle bis
dahin im Nachkommen vertreten. Dieses Verfahren ist notwendig, damit die Knoten
in der Reihenfolge zu einem Packmuster zusammengesetzt werden, die durch den
Crossover - Algorithmus festgelegt wurde. Hierdurch ist die Zulässigkeit des
Nachkommen gewährleistet.
280
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Abb. 4.4-4:
281
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Neben dem Crossover beeinflußt der Selektionsoperator das Verhalten eines
Genetischen Algorithmus wesentlich. Er dirigiert die Suche in die
vielversprechendsten Teile des Suchbaums. Zu diesem Zweck werden Individuen
hoher Qualität häufiger zur Rekombination ausgewählt. Sie sollen öfter
Nachkommen generieren, die deren gute Eigenschaften erben. Man sagt auch, daß
die Population durch die Selektion einem Lernprozeß unterworfen wird, da mit
zunehmender Generationenzahl der Anteil der qualitativ guten Individuen ansteigt.
Aber Vorsicht, einer zu häufige Wahl desselben Individuums bewirkt eine schnelle
Durchsetzung der gesamte Population mit dem genetischen Material nur eines
Individuums. Dieses kommt etwa dem Effekt der Inzucht gleich: Durch den Verlust
der genetischen Vielfalt innerhalb einer Population wird eine Qualitätssteigerung
durch die Evolution unmöglich. Die Population stagniert dann häufig in einem
schlechten lokalen Minimum. Außerdem sollte berechnet werden, daß auch qualitativ
schlechte Individuen genetisches Material enthalten können, welches beim
Crossover mit guten Lösungen zu Evolutionsschüben führt.
Bevor gängige Selektionsstrategien untersucht werden, soll aber zunächst die Frage
geklärt werden, wie die Qualität eines Individuums, dessen Fitneß, für das
Packproblem bewertet werden kann. Eine sorgfältige Bewertung von Individuen ist
notwendig, da die Fitneß die einzige Grundlage ist, anhand derer der
Selektionsprozeß seiner Wahl treffen kann.
5. Fitneß
Allgemein wird unter Fitneß die Anpassung von Individuen die Anpassung von
Individuen an ihre Umwelt verstanden. Klar ist, daß zur Lösung von
kombinatorischen Optimierungsaufgaben Individuen gefragt sind, deren
Zielfunktionswert - im Beispiel der Höhe des Packmusters - optimal ist. Jedoch nur
den Maßstab der Packmusterhöhe zur Bewertung der Fitneß von Individuen
anzulegen, erschien nicht erfolgversprechend. Fast zwangsläufig müßten in diesem
Fall viele völlig verschiedene Packmuster zur gleichen Fitneß führen. Bei m zu
packenden Rechtecken gibt es, wie eingangs erwähnt, 2 m  m! verschiedene
Packmuster, aber nur etwa m sinnvolle Packmusterhöhen. Im Mittel haben also
2 m  m! verschiedene Packmuster denselben Zielfunktionswert.
Erforderlich sind also zusätzliche Bewertungselemente für Packmuster, geeignete
Kriterien sollten effizient berechenbar sein, da die Fitneß - Funktion im Genetischen
Algorithmus sehr häufig aufgerufen wird Zu den besten Ergebnissen hat die
zusätzliche Bewertung der Schnittkantenlänge geführt. Sei h die Höhe des kleinsten
rechteckigen Kastens, der alle Rechtecke eines Packmusters umschließt. Als
Schnittkantenlänge sh wird dann sie Summe aller Rechteckseiten bezeichnet, die die
obere Begrenzung des Kasten berühren. Abb. 4.4-4 veranschaulicht diesen
Sachverhalt. Einem Individuum wird dann als Fitneß der Wert
fitness(W ) 
scale
h  scale  s h
zugeordnet. Darin ist scale einSkalierungsfaktor, dessen Wert identisch ist mit der
kleinsten ganzzahligen Potenz von 10, die größer ist als die Breite des Behälters. Bei
identischer Packmusterhöhe zweier Individuen wird demjenigen die bessere Fitneß
zugeordnet, dessen sh Wert kleiner ist. Ein kleiner sh Wert ist ein Hinweis auf ein
282
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
dichtes Packmuster unterhalb der Erhöhungen, die den Wert von s h ausmachen,
also auf ein Packmuster, dessen Höhe noch reduziert werden kann.
Abb. 4.4-4:
Hat man die Fitneßbestimmung der Individuen festgelegt, kann man sich Gedanken
darüber machen, wie man qualitativ gute Individuen im Selektionsprozeß favorisieren
will, ohne die schlechten Individuen zu sehr zu vernachlässigen. In der Literatur
werden hierzu im allgemein folgende Strategie vorgeschlagen:
6. Zufällige Wahl
Mitglieder der Population werden zufällig ausgewählt; solange die gewählten
Individuen gleichverteilt in der Population liegen, wird zwar keine gezielte
Konzentration der Suche in bestimmten Gegenden des Lösungsraums erreicht, aber
die genetische Vielfalt der Population bleibt erhalten.
7. Proportionale Wahl
Jedes Individuum wird mit einer Wahrscheinlichkeit selektiert, die seiner Fitneß
proportional ist. Qualitativ bessere Individuen werden häufiger gewählt als weniger
gute Individuen.
8. Platzabhängige Wahl
Statt über den Fitneß-Wert kann eine Gewichtung der Auswahlwahrscheinlichket
auch über die Plazierung der Fitneß des Individuums innerhalb der Population
vorgenommen werden. Dadurch kann eine Blockierung des Evolutionsprozesses
vermieden werden, die sich bei der proportionalen Wahl etwa dadurch einstellen
kann, daß die Fitneß eines einzigen Individuums die aller anderen weit übertrifft.
Die Entscheidung für oder wider Selektionsstrategie kann nicht allgemein getroffen
werden; sie hängt von dem zu optimierenden Problem ab. Für den Packalgorithmus
fiel die Entscheidung auf die platzabhängige Wahl des Vaters und die zufällige Wahl
der Mutter.
283
Neuronale Netze, Fuzzy-Control Systeme und Genetische Algorithmen
Eine selektive Entscheidung wird jedoch nicht nur zu Bestimmung der Partner in
einem genetischen Algorithmus benötigt. Auch nach der Erzeugung eines
Nachkommen muß darüber entschieden werden, welches Individuum aus der
Population entfernt werden soll, um den Nachwuchs Platz zu machen. Hierzu wird
häufig eine von dem Populationsgenetiker Darwin formulierte Survival - of - the Fittest - Strategie verwendet, die das jeweils schlechteste Individuum aus der
Population entfernt. Qualitativ bessere Individuen haben demzufolge eine größere
Chance, mehrere Generationen zu überleben, als schlechtere.
9. Applet mit dem genetischen Algorithmus für das Packproblem
http://fbim.fh-regensburg.de/~saj39122/dkst/Index.htm
4.5.3 Genetic Function Finder
http://fbim.fh-regensburg.de/~saj39122/prmeha/index.html
284