Diplomarbeit als PDF

Diplomarbeit als PDF
Fachbereich Technische Informatik
Diplomarbeit WS 95/96
Diplomand:
Jan-Erik Engels
Matrikel Nr.: 645450
Uhlandstr. 12
71409 Schwaikheim
Programmierung eines evolutionären Algorithmus
zur Optimierung eines technischen Systems
Betreuer:
Prof. Dr.-Ing. Kienzle FHT-Esslingen
Prof. Dr.-Ing. Schmidt FHT-Esslingen
Esslingen, im Januar 1996
Inhaltsverzeichnis:
DANKSAGUNG __________________________________________________________________________ 4
ERKLÄRUNG ____________________________________________________________________________ 4
KAPITEL 1: EINFÜHRUNG _______________________________________________________________ 5
KAPITEL 2: SYSTEME DER KÜNSTLICHEN INTELLIGENZ _________________________________ 6
2.1 KURZE EINFÜHRUNG IN KÜNSTLICHE NEURONALE NETZE _________________________________________ 7
2.1.1 Definition des technischen Neurons und Neuronaler Netze ___________________________________ 7
2.1.2 Einsatzgebiete der Neuronalen Netze ____________________________________________________ 7
2.1.3 Realisierung eines Neurons ____________________________________________________________ 7
2.1.4 Der Lernvorgang bei Neuronalen Netzen _________________________________________________ 8
2.1.5 Eigenschaften des trainierten Neuronalen Netzes __________________________________________ 10
2.2 FUZZY SYSTEME _______________________________________________________________________ 11
2.2.1 Die Fuzzyfizierung _________________________________________________________________ 11
2.2.2 Bewertung im Fuzzy System und die Entfuzzyfizierung _____________________________________ 14
2.2.3 Neuronale Fuzzysysteme _____________________________________________________________ 16
2.3 EVOLUTIONÄRE ALGORITHMEN ____________________________________________________________ 18
2.3.1 Begriffe der evolutionären Algorithmen _________________________________________________ 18
2.3.2 Grundphilosophien der evolutionären Algorithmen ________________________________________ 20
2.3.3 Evolutionsstrategie _________________________________________________________________ 21
2.3.3.1 Der Grundalgorithmus, die zweigliedrige Evolutionsstrategie _____________________________________21
2.3.3.2 Die Schrittweitenregelung _________________________________________________________________22
2.3.3.3 Die ()-ES mit mutativer Schrittweitenregelung _______________________________________________24
2.3.3.4 Die ()-ES mit mutativer Schrittweitenregelung ______________________________________________24
2.3.4 Die evolutionäre Programmierung _____________________________________________________ 25
2.3.4.1 Der Standard der evolutionären Programmierung _______________________________________________25
2.3.4.2 Erweiterungen der evolutionären Programmierung ______________________________________________28
2.4 DIE GENETISCHEN ALGORITHMEN __________________________________________________________ 29
2.4.1 Vererbungungsmechanismen der genetischen Algorithmen __________________________________ 29
2.4.1.1 Reproduktion ___________________________________________________________________________29
2.4.1.2 Mutation ______________________________________________________________________________29
2.4.1.3 Inversion ______________________________________________________________________________30
2.4.1.4 Crossover ______________________________________________________________________________30
2.4.1.5 Blockung und Entblockung ________________________________________________________________31
2.4.1.6 Selektion ______________________________________________________________________________31
2.4.1.7 Lösungsrepräsentation und Codierung, Lösungsbewertung _______________________________________32
2.4.1.8 Ein „sanftes“ Fehlergebirges einer Lösungstopologie ____________________________________________34
2.5 ZUSAMMENFASSUNG DER EIGENSCHAFTEN VON GA, ES UND EP __________________________________ 35
KAPITEL 3: DAS TRAVELLING SALESMAN PROBLEM ____________________________________ 36
3.1 DIE MUTATIONS-OPERATOREN DES TSP _____________________________________________________ 37
3.2 ZUR PROGRAMMIERUNG DES MATLAB-PROGRAMMS ES_TSP.M _________________________________ 46
3.3 KONVERGENZVERHALTEN DES MATLAB TSP ________________________________________________ 50
3.4 ABBRUCHBEDINGUNG DES MATLAB TSP ___________________________________________________ 51
KAPITEL 4: EIN GENETISCHER ALGORITHMUS ALS MATLAB-LÖSUNG ___________________ 52
4.1 EIN BINÄRER GENETISCHER ALGORITHMUS ___________________________________________________ 52
4.1.1 Die Fitness-Funktion des binären genetischen Algorithmus __________________________________ 53
4.1.2 Vergleich der angewandten Crossover-Methoden __________________________________________ 54
4.1.3 Die Bedieneroberfläche von GA_BIN.M ________________________________________________ 57
4.1.4 Weitere Erfahrungen aus der Benutzung von GA_BIN.M ___________________________________ 60
4.2 BEDINGUNG FÜR DEN EINSATZ VON GENETISCHEN ALGORITHMEN _________________________________ 65
4.3 WEITERENTWICKLUNGEN DER GENETISCHEN ALGORITHMEN _____________________________________ 66
KAPITEL 5: KURZE EINFÜHRUNG IN DIE MATLAB FUZZY-TOOLBOX _____________________ 68
5.1 BEDEUTUNG DER VERKNÜPFUNGSMETHODEN OR, IMP UND AGG _________________________________ 69
5.1.1 Die Or-Methode ___________________________________________________________________ 69
5.1.2 Die Implication-Methode ____________________________________________________________ 70
5.1.3 Die Aggregation-Methode ____________________________________________________________ 70
5.2 DIE DEFUZZIFIKATIONS-METHODEN ________________________________________________________ 71
KAPITEL 6: FUZZY LOGIK MIT EVOLUTIONÄREN STRATEGIEN __________________________ 74
Seite 2
6.1 DAS REGLUNGSPROBLEM DES BEISPIEL-SYSTEMS ______________________________________________ 74
6.1.1 Die physikalischen Grundlagen für die Systemsimulation ___________________________________ 77
6.1.2 Die ideale Ausgangskennlinie des Fuzzy-Reglers __________________________________________ 78
6.2 DIE PROBLEMCODIERUNG DES ES_FUZZY-REGLERS ___________________________________________ 80
6.3 DIE MUTATIONEN DES ES_FUZZY _________________________________________________________ 82
6.3.1 Die Membership-Parameter-Mutation von ES_FUZZY _____________________________________ 82
6.3.2 Die Membership-Funktions-Mutation von ES_FUZZY _____________________________________ 83
6.3.3 Die Verknüpfungs-Mutation von ES_FUZZY ____________________________________________ 84
6.3.4 Die Defuzzifikations-Mutation von ES_FUZZY ___________________________________________ 86
6.4 HILFS-KLASSIFIZIERUNG DER FUZZY-MEMBERSHIP-FUNKTIONEN __________________________________ 87
6.5 DIE BEDIENEROBERFLÄCHE DES MATLAB-PROGRAMMES ES_FUZZY.M __________________________ 89
6.5.1 Das Hauptfenster ___________________________________________________________________ 89
6.5.2 Das Ruleview-Fenster _______________________________________________________________ 92
6.5.3 Das Fenster der Fuzzy-Ausgangswerte __________________________________________________ 93
6.5.4 Das Fitness-Fenster _________________________________________________________________ 94
6.6 DIE FITNESS-FUNKTION DES ES_FUZZY-REGLERS _____________________________________________ 95
6.7 KONVERGENZVERHALTEN DES PROGRAMMES ES_FUZZY.M_____________________________________ 97
6.8 DENKBARE TECHNISCHE REALISIERUNG _____________________________________________________ 98
KAPITEL 7: DAS ANFIS-TOOL DER MATLAB-FUZZY-TOOLBOX __________________________ 100
7.1 EINE ANWENDUNG DES ANFIS-TOOLS _____________________________________________________ 102
KAPITEL 8: ERGEBNISSE DIESER ARBEIT ______________________________________________ 108
8.1 NEUE KLASSIFIZIERUNG DER GENETISCHEN ALGORITHMEN ______________________________________ 108
8.2 BEDEUTUNG DER FITNESS-FUNKTIONEN FÜR KI-OPTIMIERUNGEN ________________________________ 109
8.3 PROBLEMATIK DER ABBRUCHKRITERIEN ____________________________________________________ 109
8.4 WANN SIND KI-METHODEN SINNVOLL ANWENDBAR ? __________________________________________ 110
8.5 ABSCHLIEßENDE BEWERTUNG ____________________________________________________________ 111
KAPITEL 9: DER ZUFALLSGENERATOR VON MATLAB __________________________________ 112
9.1 ÜBERPRÜFUNG DES MATLAB ZUFALLSGENERATORS __________________________________________ 112
9.2 DER MATLAB ZUFALLSGENERATOR: ERGEBNIS UND BEWERTUNG _______________________________ 113
KAPITEL 10: GEFAHREN BEI DER ANWENDUNG VON KÜNSTLICHER INTELLIGENZ ______ 114
KAPITEL 11: LISTE DER VERWENDETEN ABKÜRZUNGEN _______________________________ 115
KAPITEL 12: QUELLEN ________________________________________________________________ 116
12.1 INTERNET ADRESSEN ZUM THEMA________________________________________________________ 116
12.2 VERWENDETE LITERATUR ______________________________________________________________ 118
KAPITEL 13: DIE BEIGEFÜGTEN DISKETTEN ___________________________________________ 119
13.1 NEFCLASS - DISKETTE _______________________________________________________________ 119
13.2 MATLAB - DISKETTE _________________________________________________________________ 119
KAPITEL 14: PROGRAMM-TEXTE ______________________________________________________ 121
14.1 DAS MATLAB-PROGRAMM GA_BIN.M __________________________________________________ 121
14.1.1 GA_BIN.M _____________________________________________________________________ 121
14.1.2 X_OVER.M von GA_BIN.M _______________________________________________________ 133
14.2 DAS MATLAB-PROGRAMM ES_TSP.M ___________________________________________________ 134
14.2.1 ES_TSP.M______________________________________________________________________ 134
14.2.2 STR_IN.M von ES_TSP.M _________________________________________________________ 147
14.2.3 STR_DEL.M von ES_TSP.M _______________________________________________________ 148
14.3 DAS MATLAB-PROGRAMM ES_FUZZY.M ________________________________________________ 149
14.3.1 ES_FUZZY.M ___________________________________________________________________ 149
14.3.2 ES_F_FIT.M von ES_FUZZY.M ____________________________________________________ 159
14.3.3 VERTEIL.M von ES_FUZZY.M ____________________________________________________ 160
14.3.4 ES_CNTRL.M von ES_FUZZY.M ___________________________________________________ 162
14.3.5 EVALMFP.M von ES_FUZZY.M ___________________________________________________ 171
14.3.6 CHG_MFP.M von ES_FUZZY.M ___________________________________________________ 173
14.3.7 Q_CALC.M von ES_FUZZY.M _____________________________________________________ 173
14.4 DAS MATLAB-PROGRAMM OPTIMAL.M _________________________________________________ 174
14.5 DAS MATLAB-PROGRAMM TEST_ANF.M ________________________________________________ 175
KAPITEL 15: GESCHÜTZTE BEGRIFFE UND WARENZEICHEN ____________________________ 177
ANHANG: NEFCLASS - A NEURO-FUZZY APPROACH FOR THE CLASSIFICATION OF DATA
Seite 3
Danksagung
Allen, die mich bei der Erstellung dieser Arbeit unterstützt haben, möchte ich an dieser
Stelle herzlich danken. Dies gilt insbesondere für meine Frau, die mich oft nur noch am
Computer sitzen sah.
Mein besonderer Dank gilt Herrn Prof. Dr.-Ing. Eberhard Kienzle von der FHTEsslingen, der sich viel Zeit für die Betreuung meiner Arbeit nahm, Ergebnisse kritisch
hinterfragte, erste Versionen dieser Arbeit aufmerksam las und mich mit zahlreichen
Anregungen unterstützt hat.
Danken möchte ich auch den Mitarbeitern des Rechenzentrums des Ultrix-Pools und
Herrn Vöhringer vom TI-Pool für Ihre Unterstützung bei der Installation der
MATLAB-Fuzzy-Toolbox, die als Version 1.0 so ihre Tücken und Fehler hatte.
Erklärung
Ich versichere, die vorliegende Arbeit selbständig verfaßt und keine anderen als die angegebenen Quellen und Hilfsmittel benutzt zu haben.
Esslingen, den 28. Januar 1996
Jan-Erik Engels
Seite 4
Kapitel 1: Einführung
Kapitel 1: Einführung
Die Ingenieurwissenschaften beschäftigen sich heute mit Problemen von immer komplexeren
Systemen. Die Vielzahl der Parameter, die in einem solchen komplexen System dessen Eigenschaften bestimmen, machen eine Optimierung dieser Systeme immer schwieriger.
Vorbild für neue Formen der Systemoptimierung kann nun die Natur sein. So wird zum Beispiel das System „Mensch“ durch alle möglichen Kombinationen von nur 4 Nukleotidbasen
beschrieben (nach Rechenberg Buchquelle [2] ca. 3*109 Kombinationen). Die möglichen Alternativen für die genetische Beschreibung des Menschen summieren sich auf mindestens
43.000.000.000. Selbst wenn diese Schätzung um einen Faktor von mehreren Milliarden falsch
liegt, ist das Ergebnis noch immer beeindruckend, denn ein Optimierungsverfahren, das sich
wie die Evolution effizient in einem solchen Suchraum zurechtfindet, verdient in der Tat
größte Aufmerksamkeit und Beachtung.
Die Natur geht im Allgemeinen verschwenderisch mit ihren Geschöpfen um. Sie nimmt keine
Rücksicht darauf, wieviele Individuen zugrunde gehen, wenn eine Adaption einer Art (des
„Genpools“) an neue Umweltbedingungen erreicht werden soll. Warum geht die Natur so vor
? Warum versucht sie nicht, mit einer minimalen Anzahl von Lebewesen auszukommen ?
Betrachtet man die Evolution als einen Suchprozeß im Raum der genetischen Rekombinationsmöglichkeiten, so wird verständlich, weshalb die Natur nicht gerade mit Individuen
„geizt“. Soll ein Genpool an sich verändernde Lebensbedingungen angepaßt werden, so ist die
Meßlatte in der Regel die Zeit. Folglich gibt es für eine möglichst effiziente Optimierungsstrategie im Wesentlichen nur zwei Alternativen: entweder werden die Generationsfolgen sehr
kurz gehalten, damit sich die Individuen in der Generationsfolge schnell den veränderten Bedingungen anpassen können, oder aber es werden jeweils möglichst viele Individuen zur gleichen Zeit erzeugt, so daß auf diese Weise die benötigte Evolutionszeit minimiert wird.
Die Evolution verfolgt vermutlich eine annähernd optimale Kombination dieser beiden Strategien. Die bei fast allen Arten unterschiedliche Kombination von Reproduktionszeit und Reproduktionsquote bewirkt im Sinne klassischer Suchstrategien eine gekoppelte Tiefen- und
Breitensuche bzw. eine Kombination aus serieller und paralleler Suche.
Die Idee dieser Diplomarbeit ist es, diesen eindrucksvollen Optimierungsalgorithmus, im
Weiteren evolutionäre Strategie (ES) genannt, mit der immer aktueller werdenden Theorie der
unscharfen Mengen („Fuzzy Logik“) zu kombinieren, um - erst einmal im Kleinen - einen sich
selbst optimierenden Regler für ein physikalisches System zu entwerfen.
In dieser Richtung gibt es verschiedene Realisierungsbemühungen in Kombination von
Fuzzy-Systemen mit lernenden Neuronalen Netzen (besondere Bemühungen werden hier von
der TU Braunschweig unternommen, siehe Computerquelle {1} und die erste der beigelegten
Disketten). Diese Optimierungsmethode hat jedoch den Nachteil, daß das Gelernte nicht einfach in Form von Regeln wieder aus dem System extrahiert werden kann. Es mangelt Systemen also an Transparenz. Ein Neuronales Netz lernt zwar, der Betrachter lernt jedoch nichts
aus dem Netz. Diesen Nachteil soll die Kombination von ES und Fuzzy ausmerzen.
Das Ergebnis sollte ein selbstlernender Regler sein, dessen Regelwerk leicht durch einen Benutzer zur Überprüfung und Weiterverwendung abgelesen werden kann.
Seite 5
Kapitel 2: Systeme der künstlichen Intelligenz
Kapitel 2: Systeme der künstlichen Intelligenz
Folgende Überlegung zum Schachproblem ist aus [1] entnommen:
Um in einer Schachstellung einen möglichst guten Zug zu finden, muß man sich die Folgen,
die aus dem Zug entstehen können, klargemacht haben. Diese „Folgen“ erkennt man erst,
wenn man alle Züge, die der Gegner als nächstes ziehen kann, durchdacht hat und wenn man
sich für jeden dieser Züge einen guten Antwortzug überlegt hat; für jeden Antwortzug muß
man sich über die Folgen klargeworden sein usw. Nimmt man an, daß man in einer gegebenen
Stellung etwa 25 verschiedene Züge machen kann und daß man 10 Halbzüge (5 eigene und 5
gegnerische Züge) vorausdenken will, so muß man
2510  9.5*1013
Stellungen überschauen und bewerten können. Ein außerordentlich schneller Computer, der
250 000 Stellungen in der Sekunde untersuchen kann und diese wirklich alle berechnen will
(„brutal force“), wäre allerdings etwas mehr als 12 Jahre damit beschäftigt, zu einer Stellung
den optimalen Zug (innerhalb der 10 Halbzüge) zu finden.
Es ist ersichtlich, daß man sich bemüht, intelligentes Verhalten beim Menschen und in seiner
Umwelt zu erfassen um dieses in die Programmierung der Computer einfließen zu lassen.
Diese Bemühungen führten zur Forschung über die künstliche Intelligenz (KI).
KI Systeme
EvolutionäreAlgorithmen
Genetische
Algorithmen
Fuzzy
Logik
Neuronale
Netze
EvolutionsStrategien
Genetische
Programmierung
EvolutionsProgrammierung
Im Folgenden werden die Neuronalen Netze und die Theorie der Fuzzy Logik in einer kurzen
Einführung dargestellt, bevor dann auf die unterschiedlichen evolutionären Algorithmen eingegangen wird.
Seite 6
Kapitel 2: Systeme der künstlichen Intelligenz
2.1 Kurze Einführung in künstliche Neuronale Netze
2.1.1 Definition des technischen Neurons und Neuronaler Netze
Ein Neuronales Netz (NN) besteht im Wesentlichen aus einfachen Verarbeitungseinheiten,
(eben den Neuronen), und Verbindungen zwischen ihnen, die wie jene der echten Nervenzelle
als Synapsen bezeichnet werden. Wie das biologische Vorbild ist eine Synapse eine Einbahnverbindung: Sie vermittelt die Aktivität des Ausgangsneurons an das Zielneuron - wie stark
und mit welchem Vorzeichen, das hängt von einem zahlenmäßigen Parameter ab, dem Gewicht der Verbindung. Ein NN lernt, indem es diese Verbindungsgewichte verändert.
Unter Neuronalen Netzen versteht man die Verschaltung eben dieser gleichartigen, relativ
einfachen Bausteine zu einem Netzwerk. Die Informationsweiterleitung erfolgt in diesem
Netz nach den Prinzipien der biologischen Nervenzelle, wobei künstliche NN lange nicht die
Komplexität der biologischen Nervenzellen erlangen können.
2.1.2 Einsatzgebiete der Neuronalen Netze
NN sind Modelle für spezielle Formen der Parallelverarbeitung, wobei die Systeme ihre künftigen Tätigkeiten in einem vorgeschalteten Prozeß erlernen. NN werden zur Mustererkennung
und Musterzuordnung, zur Sprachverarbeitung, zur Bildverarbeitung, zur Leiterbahnentflechtung, zur Realisierung von Assoziativspeichern und zum schnellen Auffinden guter Näherungslösungen bei komplexen Problemen der Physik, der Biologie und der Psychologie eingesetzt.
2.1.3 Realisierung eines Neurons
Die Bausteine von NN sind modifizierte Schwellwertelemente, früher oft mit eigenem Speicher. Das einzelne Neuron kann mit vielen weiteren Neuronen verbunden sein.
Das Grundmodell für Neuronen zeigt die nebenstehende
Abbildung. Die n Eingabeleitungen, an denen die Eingabewerte xi anliegen, entsprechen den Enden von (in der
Regel) verschiedenen anderen Neuronen, die über Synapsen mit Dendriten (Auswüchsen) der Zelle verbunden sind.
Entsprechend der unterschiedlichen Größe der Synapsen
werden die Eingabeleitungen mit den Faktoren wi gewichtet. z ist der Aktivierungszustand des Neurons, der durch
die Eingabegrößen (xi, wi) entsprechend einer Funktion F
zum Zustand z’ verändert wird. Der durch das Neuron
weitergeleitete Ausgabewert y=f(x,w,z) ist somit abhängig
von den Eingaben, den Gewichtungen und dem Zustand.
Ein formales Neuron N = (I, O, Z, n, f, F) ist somit eindeutig bestimmt durch
 die Eingabemenge I
 die Ausgabemenge O
 die Zustandsmenge Z
 die Gewichtsmenge W
 die Zahl der Eingänge n
Seite 7
Kapitel 2: Systeme der künstlichen Intelligenz
 die Zustandsfunktion
F:
In x Wn x Z  Z
 die Ausgabefunktion
f:
In x Wn x Z  O
Wenn die Mengen I, O, W und Z endlich sind, dann ist ein formales Neuron nichts anderes als
ein endlicher Automat mit Ausgangsgrößen.
Ein künstliches NN besteht aus vielen formalen Neuronen die untereinander verbunden sind.
Ein NN ist somit ein gerichteter Graph dessen Knoten die Neuronen bilden. Bezüglich der
Anordnung der formalen Neuronen und ihrer Verbindungen unterscheidet man zwischen folgenden
Netzstrukturen:





zyklenfreie Strukturen
rückgekoppelte Strukturen
geschichtete Strukturen
vollständig vernetzte Strukturen
beliebige Strukturen
Besondere Bedeutung erlangten folgende Netzstrukturen:
 feedforward-Netze
 Hopfield-Netze
Zyklenfreie Netzstruktur, bei der alle Kanten in Richtung zu den
Ausgängen gerichtet sind. Geschieht dies über mehr als eine Ebene
spricht man von einem „shortcut“-Netz
Ein wichtiger Spezialfall sind die back-propagation-Netze.
Alle Knoten (Neuronen) sind direkt miteinander verbunden (Haupteinsatzgebiet in der Bildverbesserung / Bildrekonstruktion)
(Quelle der Auflistung: [1] Seite 468)
2.1.4 Der Lernvorgang bei Neuronalen Netzen
Zu Beginn werden die Gewichte w1 .. wn mit einem zufälligen Anfangswert initialisiert. Das
Netz erhält eine Eingabe, die Antwort des NN wird registriert:
Mit der Information über die Systemantwort berechnet man den Fehler gegenüber dem gewünschten Systemverhalten. Daraufhin werden die Gewichte verändert, mit dem Ziel die Systemantwort zu verbessern („Error-Backpropagation“: Der Fehler wird durch das NN vom
Ausgang in Richtung Eingang verfolgt und die Gewichte an den Eingängen der Neuronen
nach den Vorgaben des Backpropagation-Algorithmus verändert).
Diesen Prozeß wiederholt man mehrfach (das System wird „belernt“). Es braucht im Allgemeinen einige hundert bis mehrere tausend Lernzyklen (Epochen), bis ein stabiler Zustand
erreicht ist ( wenn der Restfehler nicht mehr kleiner wird oder zu „Null“ geworden ist).
Voraussetzung für ein erfolgreiches Lernen sind:
 Die Korrektheit und damit die Widerspruchsfreiheit des „Lern-Datensatzes“
 Ausreichende Anzahl von Lernzyklen und Erreichen der Fehlerkonvergenz gegen Null
 Eine dem Problem angemessene Komplexität (Anzahl der Gewichte und Neuronen) des
Netzwerkes, damit kein „überlernen“ (Overfitting) oder „unterlernen“ (Underfitting) mögSeite 8
Kapitel 2: Systeme der künstlichen Intelligenz
lich ist. Zur Beurteilung der benötigten Größe des NN wird in [1] folgende Regel angegeben:
Mit n Neuronen lassen sich 2n Ausgangslösungen realisieren.
Seite 9
Kapitel 2: Systeme der künstlichen Intelligenz
2.1.5 Eigenschaften des trainierten Neuronalen Netzes
 NN sind zur Verallgemeinerung fähig, d.h. das Netz kann auch zu einem neuen, nicht gelernten Eingangswort einen Ausgangswert generieren.
 Eingangsdaten können parallel bearbeitet werden -> Geschwindigkeitssteigerung
 Ein NN das ausreichend dimensioniert ist, ist redundant in seiner Struktur. Damit wird das
System zu einem gewissen Maß unempfindlich gegenüber gestörten Eingangsdaten und
Neuronen-Ausfällen.
 Die durch die Gewichtung und Verknüpfung gebildeten Regeln lassen sich nur schwer aus
dem NN extrahieren.
Seite 10
Kapitel 2: Systeme der künstlichen Intelligenz
2.2 Fuzzy Systeme
2.2.1 Die Fuzzyfizierung
Ein Fuzzy-System hat in der Regel exakte Eingangsgrößen, die Meßwerten aus der realen
Welt entsprechen und deshalb als diskrete Werte vorliegen. Will man nun eine Bewertung
dieser Eingangsgrößen im Sinne einer Zuordnung von bestimmten Attributen vornehmen, so
wird ein Programmierer einen auf Erfahrungen begründeten Grenzwert ziehen, um eine Klassifizierung der Eingangsgrößen zu ermöglichen.
Ein bekanntes Problem stellt in dieser Beziehung die Klassifizierung einer Person anhand
ihrer als exakte Zahl vorliegenden Körpermaße als „groß“ (µ=1) oder „nicht groß“ (µ=0) dar:
Die Einführung eines derartigen, harten „Schwellwertes“ führt dazu, daß ein minimaler Unterschiedswert in der Größe von zwei Personen eine Einteilung in zwei verschiedene Gruppen
zur Folge haben kann.
Wird jedoch ein kontinuierlicher Übergang zwischen den beiden Extrema gewählt und eine
Zuordnung anhand dieser Kurve („Zugehörigkeitsfunktion“) durchgeführt, sind bessere (fast
umgangssprachliche) Zuordnungen der beiden Personen zu dem Bereich zwischen „nicht
groß“ (µ=0) und „groß“ (µ=1) möglich. Der exakte Eingangswert ist fuzzyfiziert worden.
Seite 11
Kapitel 2: Systeme der künstlichen Intelligenz
Seite 12
Kapitel 2: Systeme der künstlichen Intelligenz
Bei dem Problem der Zuordnung der Körpergröße ist schon eine mögliche Form einer Zuordnungskurve vorgestellt worden. Verschiedene weitere Zuordungsfunktionen sind denkbar. Die
folgenden Beispiele stellen eine Auswahl der in der MATLAB „Fuzzy Logic Toolbox“ vorhandenen Zuordnungsfunktionen dar. Unter den Kurven ist jeweils der Name der Zuordnungsfunktion und die zum Bild gehörigen kurvenbeschreibenden Parameter der Zuordungsfunktion
aufgeführt.
Wie diese Kurven bei der Fuzzyfizierung angewendet werden, soll im nächsten Abschnitt
dargestellt werden.
Seite 13
Kapitel 2: Systeme der künstlichen Intelligenz
2.2.2 Bewertung im Fuzzy System und die Entfuzzyfizierung
Ein aus dem Handbuch der MATLAB „Fuzzy Toolbox“ entnommenes Beispiel verdeutlicht
die Funktionsbildung im Fuzzy-System und die Methodik der Entfuzzyfizierung:
Es geht um die Bewertung eines Restaurants. Die beiden Bewertungskriterien sind die Qualität des Services und die Güte des angeboten Essens. Diese Kriterien werden jeweils als Zahlen
zwischen „0“ und „10“ dem Fuzzy System übergeben und dieses soll dann eine der Qualität
des Restaurants äquivalente Zahl (die Größe des Trinkgeldes, das dieser Kunde zu geben bereit ist) als Ausgangsgröße liefern (hier: 60.3 %).
Die Kurven (poor, rancid, cheap, good ...) sind Kurven von Zuordnungfunktionen. Diese werden in  von dem scharfen Eingangswerten für service und food an einer bestimmten Stelle
geschnitten und diese Schnittpunkte werden nach rechts projiziert.
An der Stelle  der Grafik wird das Maximum der beiden Projektionslinien zum Schneiden
einer Zuordnungskurve für die Ausgangsfunktion verwendet, das Ergebnis dieser Operation
ist in  zu sehen. Diese beschnittenen Kurven werden in  überlagert und in  wird der
Schwerpunkt dieser Überlagerungskurve gebildet. Der X-Achsenwert dieses Schwerpunktes
bildet den Ausgangswert des Fuzzy-System ( Entfuzzifizierungswert).
Seite 14
Kapitel 2: Systeme der künstlichen Intelligenz
Seite 15
Kapitel 2: Systeme der künstlichen Intelligenz
2.2.3 Neuronale Fuzzysysteme
Auf einer der beiliegenden Disketten befindet sich das Programm eines Neuronalen Fuzzy
Reglers NEFCLASS, entwickelt an der TU Braunschweig
NEFCLASS basiert auf einem 3-stufigen feedforward Fuzzy Perceptron und kann - wie alle
Neuronalen Netze - Eingangsdaten klassifizieren (Gruppen zuordnen). Das Fuzzy-Perceptron
ist eine Eigenentwicklung der TU Braunschweig, wobei die Gewichte des NN als FuzzyRegeln ausgeführt worden sind. Die Mathematik der NN wurde auf diesen Umstand angepaßt
(Eingangs- und Ausgangs-Funktionen, die Backpropagation-Funktion).
NEFCLASS wird mit einem vom Benutzer erstellten Datensatz trainiert, wobei dieser Datensatz die Eingangswerte und die zugehörige Klassifizierung enthält.
NEFCLASS ermittelt die Fuzzy-Regeln, indem es Fuzzy-Datensätze liest und einem NN
übergibt, das diesen Fuzzy-Datensatz mit Hilfe einer Fehler-Backpropagation optimiert. Das
Ergebnis ist ein trainiertes NN und ein optimierter Fuzzy-Datensatz, der dann auch in FuzzySystemen ohne NN zum Einsatz kommen kann.
Nach dem Lernprozess kann das gebildete Neuronale Fuzzy Netz zur Klassifizierung von neuen, bisher unbekannten
Eingangsdaten benutzt werden.
Das System kann dabei die Eingangsdaten mit Hilfe einer Fuzzy-ZuordnungsFunktion klassifizieren, die folgende
Form haben kann:
„IF x1 is A1 and x2 is A2 and x3 is A3
and x4 is A4 THEN the pattern
(x1,x2,x3,x4) belongs to class i“,
wobei A1 - A4 die umgangssprachlichen
Ausdrücke
der
Fuzzy-ZuordungsFunktion repräsentieren. Da die Eingangsgrößen xi und die Zuordungsvariablen Ai bekannt sind, kann der Zustand
des NN nach dem Lernvorgang sehr einfach vollständig beschrieben werden. Die
durch NEFCLASS ermittelten Regeln
stehen also dem Benutzer, ganz anders
als bei üblichen NN, zur weiteren Verarbeitung zur Verfügung.
Das belernte System klassifiziert nach
Nauck, Kruse [17] von neuen (unbekannten) Eingangsdaten zwischen 97 % und
100 % richtig.
Seite 16
Kapitel 2: Systeme der künstlichen Intelligenz
Als Anlage findet sich am Ende dieser Arbeit ein Artikel der Herren Professoren Nauck und
Kruse mit weiteren Informationen zu NEFCLASS.
Seite 17
Kapitel 2: Systeme der künstlichen Intelligenz
2.3 Evolutionäre Algorithmen
Die evolutionären Algorithmen versuchen ein technisches System durch zufällige Veränderung der systembeschreibenden Parameter zu verbessern. Verbesserungen sind immer dann zu
verzeichnen, wenn ein technisches System für seine Zielfunktion (sein Anwendungsgebiet)
besser geeignet ist, als vor der willkürlichen Veränderung.
2.3.1 Begriffe der evolutionären Algorithmen
Die Parameter (Zahlenwerte) eines zu optimierenden Systems müssen im Computer in einer
für die Verarbeitung durch Prozessoren geeigneten Art und Weise abgelegt werden. Die Zusammengehörigkeit dieser Parameter muß durch die Struktur der Speicherung gewährleistet
werden. Die Speicherung kann
 in Form von ASCII-Zahlenstrings erfolgen.
Zum Beispiel stellt die als Zeichenkette kodierte Zahlenfolge „01100101" einen Zahlenstring dar, in dem die Eigenschaften eines System gespeichert worden sind.
 in Form eines Vektors oder einer Matrize mit Zahlenwerten erfolgen.
Zum Beispiel kann der MATLAB-Vektor [1 -1.4 3 4 0 1 -2] eine solche Struktur sein.
Für alle diese Speicherstrukturen gilt, daß sie durch ein Programm interpretiert werden müssen, um eine bestimmte Bedeutung (beispielsweise die Flugeigenschaften eines Flugzeugflügels) repräsentieren zu können.
Zur besseren begrifflichen Beschreibung wurden die verschiedenen Teile einer solchen Struktur, in Anlehnung an die Biologie, mit den Bezeichnern ihres biologischen Äquivalentes belegt (die Darstellung der Gene als Kreise mit einer Variablen als Platzhalter wird im Weiteren
häufig Verwendung finden):
Da in der Biologie Paare von jeweils zwei verschiedenen, aber untrennbar zusammengehörigen chemischen Substanzen die Chromosomeninformation bilden, wurden für die Darstellung
der Chromosomen in dieser Arbeit diese beiden Teilketten zusammengefaßt.
Seite 18
Kapitel 2: Systeme der künstlichen Intelligenz
Somit verändert sich die Darstellung eines Chromosoms wie folgt:
Veränderungen der Chromosomeninformationen können somit durch Veränderungen der Variablenwerte der im Chromosom gespeicherten Zahlen-Vektoren durchgeführt werden.
Zusammenfassung und Einführung weiterer Begriffe:
Begriff
Bedeutung
Gen
Als Zahl kodierte Information,
Speicher für einen Parameter eines Systems
Chromosom
Zusammenfassung von mehreren Genen zu
einer übergeordneten Struktur
Population (von Individuen)
Menge von Strukturen (Lösungsalternativen)
gebildet aus Chromosomen
Individuum
Struktur (enthält die in geeigneter Weise repräsentierten Elemente einer Lösung)
Ein Individuum wird durch ein Chromosom
repräsentiert.
Fitness
Lösungsqualität hinsichtlich der relevanten
Zielkriterien, Grad der Anpassung an einen
Lebensraum oder eine Problematik.
Wird von einem vom Benutzer entwickelten
Programm bestimmt und als reeller Zahlenwert ermittelt.
Eltern
Die zur Reproduktion ausgewählten Individuen einer Generation von Individuen.
Elter
ein Elternteil (bei Reproduktion ohne Partner)
Kinder, Nachkommen
die von den Eltern abgeleiteten, veränderten
Chromosomen
Generation
Verfahrensiteration
(eine Stufe der Optimierung)
Nur bei genetischen Algorithmen:
Gen
Bei den genetischen Algorithmen kann das
Gen nur zwei Zustände annehmen
"0" und „1"  binäres Gen
Allel
Bitwert (Ausprägung eines Genes,
der Bitwert, die Zustände „0" oder „1")
Locus
Positions-Nummer eines bestimmten Bits
innerhalb eines Chromosoms
Genotyp
codierte Lösung
Phänotyp
decodierte Lösung
Seite 19
Kapitel 2: Systeme der künstlichen Intelligenz
2.3.2 Grundphilosophien der evolutionären Algorithmen
Evolutionäre Algorithmen (EA) lassen sich in verschiedene Formen unterscheiden:




Evolutionsstrategien (ES)
Evolutionäre Programmierung (EP)
Genetische Algorithmen (GA)
Genetische Programmierung (GP, Sonderform der GA)
Der prinzipielle Unterschied zwischen GA und der Evolutionsstrategie besteht darin, daß die
GA hauptsächlich die optimale Problemlösung mit Hilfe des Crossovers sucht (die nächste
Generation entsteht durch „Mischen“ der Geninformation), während die ES zur Problemlösung den Mechanismus der Mutation (willkürliche Veränderung einzelner Gene oder einzelner Gengruppen) als Hauptoperation benutzt.
Durch Weiterentwicklung der GA und der ES haben beide Evolutions-Optimierungen die
„reine Lehre“ verlassen und sich einander in ihrer Anwendung soweit angenähert, daß heute
kaum noch eine Trennung sinnvoll erscheint. Dennoch sollen innerhalb dieser Diplomarbeit
die Unterschiede der beiden Entwicklungsrichtungen noch genauer untersucht werden.
Seite 20
Kapitel 2: Systeme der künstlichen Intelligenz
2.3.3 Evolutionsstrategie
2.3.3.1 Der Grundalgorithmus, die zweigliedrige Evolutionsstrategie
Bei der zweigliedrigen Evolutionsstrategie, die auch als (1+1)-ES bezeichnet wird, handelt
es sich um die einfachste Nachahmungsstufe der biologischen Evolution. Es werden nur die
Prinzipien Mutation (willkürliche Genveränderungen) und Selektion (Auswahl der besten
Individuen für die nächste Generation) verwendet. Bei der Bezeichnungsweise (1+1)-ES steht
die erste 1 für die Anzahl der Eltern, die zweite für die Anzahl der Nachkommen. Das „+“
bedeutet, daß der bisherige Elter auch zum Elter der nachfolgenden Generation werden kann,
wenn er einen höheren Qualitätswert als der Nachkomme aufweist.
Der Algorithmus für Mutation, Bewertung und Selektion bei der (1+1)-ES lautet:
Mutation:
Von einem für die Fortpflanzung mit Hilfe einer Zufallszahl ausgewählten Chromosom der Elterngeneration (durch einen Zahlenvektor repräsentiert) wird eine Kopie erstellt. Zu dieser Kopie wird ein Zufallsvektor mit normalverteilten Zufallszahlen
addiert oder die Reihenfolge der im Gen gespeicherten Informationen wird willkürlich verändert. Hierdurch entsteht ein verändertes Chromosom, der Nachkomme.
Bewertung:
Die bei der Mutation entstandenen Nachkommen werden in ihrer Qualität (Tauglichkeit für die Lösung eines Problems, Überlebensfähigkeit) bewertet. Der Qualitätswert
wird von einer Funktion als reeller Zahlenwert bestimmt.
Selektion:
Von den Eltern und den Nachkommen werden diejenigen zur nächsten Elterngeneration, die die besseren Qualitätswerte aufweisen, wobei Qualitätsgleichheit als Verbesserung gewertet wird.
Im Folgenden ist eine solche „Mutation" durch Addition zu sehen.
Auf welches Problem sich die Informationen der Gene dieser Chromosomen beziehen, sei an
dieser Stelle noch nicht von Bedeutung.
Seite 21
Kapitel 2: Systeme der künstlichen Intelligenz
2.3.3.2 Die Schrittweitenregelung
Bevor auf weitere Möglichkeiten der Realisierung von evolutionären Strategien eingegangen
werden kann, muß noch der Begriff der Schrittweitenregelung eingeführt werden.
Die „Schrittweite" bestimmt während der Erzeugung eines Nachkommens (Kindes) aus den
Genen eines Elters, wie stark diese Veränderung durch Addition von Zufallszahlen zu den
Genen des Elters ausfallen darf (im Beispiel der Grafik auf Seite 21 wäre dies die maximale
Zahlengröße, die bei der Erzeugung des Kindes zum Eltern-Chromosom addiert werden dürfte).
Kernstück der Theorie der Evolutionsstrategie ist die Feststellung der Existenz eines Evolutionsfensters, welches aussagt, daß ein wirksames Fortschreiten bei der Lösungsverbesserung
nur bei einer Schrittweite möglich ist, die optimal an die derzeitige Topologie des Qualitätsgebirges (der Nähe der aktuellen Lösung an der optimalen Lösung, siehe auch spätere Seite
34) angepaßt ist. Es konnte gezeigt werden, daß Evolution durch Mutation und Selektion nur
in einem sehr schmalen Schrittweitenbereich, dem sogenannten Evolutionsfenster, auftritt.
Im nebenstehenden Bild ist die
Fortschrittsgeschwindigkeit
des
besten Individuums über der
Schrittweite aufgetragen. Es ist außerhalb des Evolutionsfensters bei
zu kleiner Schrittweite nur ein sehr
geringer, bei zu großer Schrittweite
eventuell sogar ein negativer Fortschritt, also ein Rückschritt, erreichbar.
: Schrittweite
: Fortschritt der Lösungsgüte
(Bild entnommen aus [2])
Der Fall des Rückschritts tritt dann ein, wenn das Ziel der Evolution sehr nahe ist, jedoch die
Entfernung zu diesem Ziel nach der Mutation eines Elters bei einem zu großen Schritt zugenommen hat (bei der Annäherung über das Ziel „hinausgeschossen" wurde).
Die dynamische Anpassung der Mutationsschrittweite an das Evolutionsfenster ist in den im
Folgenden dargestellten höheren Nachahmungsstufen der Evolution mit Hilfe der von Rechenberg in [2] angedachten „mutativen Schrittweitenregelung“ realisiert.
Die Idee hierfür wurde aus [7] entnommen.
Bei diesen Algorithmen wird die Mutationsschrittweite als zusätzliche Strategievariable
eingeführt und wird wie die sonstigen Objektvariablen einer Variation unterworfen. Die
Schrittweitenreglung ersetzt aber nicht die willkürliche Genmutation, sie soll diese zur Beschleunigung des Konvergenzverhaltens lenken. Die aktuelle Schrittweite wird als Liste mit
Bezug zur Liste der Chromosomen der Eltern im Speicher abgelegt.
Die Variation der Eltern-Schrittweite wird meist auf die folgende Weise durchgeführt („deterministische Schrittweitenregelung“):
Seite 22
Kapitel 2: Systeme der künstlichen Intelligenz
 Bei 1/3 der Nachkommen wird die Schrittweite um den Faktor 1.5 erhöht
 Bei 1/3 der Nachkommen wird die Schrittweite um den Faktor 1.5 erniedrigt
 Bei 1/3 der Nachkommen bleibt die Schrittweite gleich
Seite 23
Kapitel 2: Systeme der künstlichen Intelligenz
Nun soll auf weitere mögliche Realisierungsvarianten von evolutionären Systemen eingegangen werden:
2.3.3.3 Die ()-ES mit mutativer Schrittweitenregelung
Dieser Algorithmus bildet die Natur in stärkerem Maße nach und ist wesentlich leistungsfähiger als die (1+1)-ES-Algorithmen von Seite 21.
Variations-Teil:
Von  Eltern einer Generation werden -Mal zufällig ein Elter ausgewählt. Die
Schrittweite wird nach dem zuvor beschriebenen Algorithmus variiert und auf den
Nachkommen übertragen. Nun wird unter Berücksichtigung dieser Schrittweite der
Nachkomme mutiert.
Selektions-Teil:
Hier wird zwischen verschiedenen ()-ES-Ausprägungen unterschieden.
 (+)-ES
Von den + Individuen werden die besten  zu Eltern der nächsten Generation
 (,)-ES
Hier werden nur die  Nachkommen zur Selektion zugelassen
2.3.3.4 Die ()-ES mit mutativer Schrittweitenregelung
Bei dieser Strategie besteht die Population aus  Eltern mit  Nachkommen, wobei bei der
Generierung der Nachkommen jeweils die Parameter von  Eltern mutiert und auf einen
Nachkommen übertragen werden.
Variations-Teil:
Die  an der Bildung des Nachkommen beteiligten Eltern werden per Zufall ausgewählt und deren Parameter bilden (wiederum per Zufall ausgewählt) die Parameter des
Nachkommen. Die Schrittweite für die Mutation ergibt sich aus einer Mittelwertbildung aus den Schrittweiten der  Eltern.
Selektions-Teil:
Hier wird zwischen verschiedenen ()-ES-Ausprägungen unterschieden.
 (/+)-ES
Von den + Individuen werden die besten  zu Eltern der nächsten Generation
 (/,)-ES
Hier werden nur die  Nachkommen zur Selektion zugelassen
Seite 24
Kapitel 2: Systeme der künstlichen Intelligenz
2.3.4 Die evolutionäre Programmierung
2.3.4.1 Der Standard der evolutionären Programmierung
(Zitate sind aus [3] entnommen, aber nicht einzeln gekennzeichnet)
Der Lösungsansatz der evolutionären Programmierung (EP) ist dem der Evolutionsstrategien
in hohem Maße ähnlich.
Die EP kennt grundsätzlich keine Restriktionen hinsichtlich der Lösungscodierung (Gen kann
einen Bitwert, eine reelle Zahl oder kurze Stücke von Programm-Codes enthalten), damit
sich die Lösungscodierung bei der Entwicklung eines EP-Systems in möglichst natürlicher
Weise aus der gegebenen Aufgabenstellung ergeben kann. Die EP benutzt als einzigen Suchoperator zur Lösungsoptimierung die Mutation. Es findet eine abgeänderte Form der Schrittweitenregelung Anwendung.
EP beruht auf der Annahme, daß im Verlaufe der Evolution nur das Verhalten (PhänotypEbene) und nicht zugrundeliegende genetische Strukturen Objekt der Anpassung sind. Mutationen werden hier als phänotypische und nicht genotypische Erscheinungen begriffen.
Der Ablauf von Standard-EP weist starke Ähnlichkeit zu einer strikt mutationsbasierten
(+)-ES mit folgenden Besonderheiten auf:
 Aus jedem Elter wird durch Kopieren ein Nachkomme erzeugt
 Bei der Mutation wird zu den Genen des Individuums eine normalverteilte Zufallsvariable
mit dem Erwartungswert null und dynamisch veränderbarer Standardabweichung (Mutationsschrittweite) addiert
 Die Mutationsschrittweite hängt vom elterlichen Fitnesswert ab
 Fitness wird immer als Differenz zum globalen Optimum aufgefaßt: eine gute Lösung besitzt somit einen kleinen Fitnesswert  Festlegung des besten Fitnesswertes auf „Null"
 Es finden „Selektions-Wettkämpfe" zur sogenannten „Stochastischen Selektion“ unter den
Individuen statt. Dazu muß jedes der Eltern und Kinder gegen K gleichverteilt-zufällig bestimmte Konkurrenten aus der Vereinigungsmenge von Eltern und Kindern (dem Genpool)
antreten. Sieger und Verlierer werden dabei durch einen Vergleich der Fitnesswerte bestimmt. Die Anzahl wi der Siege jedes Individuums ai (mit i = 1,2, ..., 2µ) bestimmt sich
als:
1 falls Fitness a i  Fitness a r

0 sonst
g 1

wobei r  i und r eine gleichverteilte Zufallszahl im Intervall [1,2µ] ist.
K
wi
  wg
mit w g
 Eine Übernahme in die nächste Generation findet nicht über den ermittelten Fitnesswert
eines Individuums statt, sondern über die Anzahl der gewonnenen Wettkämpfe wi
 Man richtet sich bei der Selektion also nicht mehr direkt nach dem Fitnesswert, sondern
nach der Anzahl der gewonnenen Wettkämpfe. Dadurch haben auch qualitativ „schlechtere“ Lösungen eine positive Selektionswahrscheinlichkeit. Je höher die Anzahl K von Wettkämpfen pro Individuum ist, um so härter wird die Selektion. Damit kann die Selektionsintensität sehr flexibel festgelegt werden.
Seite 25
Kapitel 2: Systeme der künstlichen Intelligenz
 Die hohe Anzahl an Vergleichsoperationen bei ausgiebigen Wettkämpfen verursacht einen
erheblichen Bedarf an Rechenzeit bei der Berechnung einer Generation
Seite 26
Kapitel 2: Systeme der künstlichen Intelligenz
Veranschaulicht wird der Ablauf der EP in folgendem Pseudo-Code (Quelle: [3], erweitert):
5
10
15
20
25
30
35
40
45
50
60
65
70
75
80
85
90
95
Start
Generiere Startpopulation von  Individuen zufällig
Bewerte Startpopulation auf Basis der Fitnessfunktion für späteren Vergleich mit der
Generation der Nachkommen und zur Festlegung der Schrittweite für die Mutation
Aktuelle Population = Startpopulation
Wiederhole
Intermediäre Population = aktuelle Population
Für i=1 bis  wiederhole
Generiere i'ten Nachkommen durch Kopieren des i'ten Elters
Mutiere den i'ten Nachkommen mittels normalverteilter Zufallsvariablen
Bewerte i'ten Nachkommen auf Basis der gegebenen Fitnessfunktion
Schleifenende
Für j=1 bis 2 ( Eltern und  Kinder) wiederhole
Führe sequentielle Wettkämpfe (Fitnessvergleiche) zwischen Individuum j
und W anderen zufällig bestimmten Individuen der intermediären Population durch und halte die vom Individuum j erzielten Siege fest
Schleifenende
Bilde Rangordnung der Individuen der intermediären Population auf Basis
ihrer erzielten Siege, wobei bei gleicher Sieges-Anzahl die Fitnessbewertung
der Individuen zur weiteren Sortierung herangezogen wird
Wähle die  obersten Individuen in der Rangfolge als neue aktuelle Population
bis Abbruchbedingung erfüllt ist
Drucke Ergebnis, dann Stop
Für die EP wurde kein Beispiel als MATLAB-Lösung realisiert.
Seite 27
Kapitel 2: Systeme der künstlichen Intelligenz
2.3.4.2 Erweiterungen der evolutionären Programmierung
Zur vollständigen Darstellung der gegenwärtig diskutierten Ansätze für evolutionäre Programmierung sollen nun weitere Typen der EP kurz vorgestellt werden:
(Entnommen aus [3])
1. Die erste Erweiterung des Standard-EP-Ansatzes betrifft die Zahl der Nachkommen während jeder Iteration (Generation). In einer als Continuous Evolutionary Programming
bezeichneten Variante wird vorgeschlagen, nur noch einen Nachkommen je Iteration zu erzeugen. Dadurch soll ein gleichmäßigeres Optimierungsverhalten gewährleistet werden.
Dies führt jedoch bei Problemen mit vielen beschreibenden Parametern zu einer starken
Vergrößerung der bis zur Problemlösung benötigten Generationenzahl.
2. Im vigorous competition model wird an das Continuous-Modell noch die zusätzliche Forderung gestellt, daß dieses einzelne, zur Iteration ausgewählte, Individuum immer nur das
jeweils beste Individuum der Elterngeneration sein darf. Eine solche Vorgehensweise ist im
Endstadium der Optimierung effizienter als das Continuous-Modell.
3. Bei der Meta-EP wird die Mutationsschrittweite nicht aus der Größe des berechneten Fitnesswertes bestimmt, sondern durch eine Menge von Schrittweiten-Vektoren, die ebenfalls
der Mutation unterworfen werden.
Desweiteren existieren eine Vielzahl von Variationen der einzelnen Typen untereinander (wie
zum Beispiel eine „Continuous Meta-EP").
Seite 28
Kapitel 2: Systeme der künstlichen Intelligenz
2.4 Die genetischen Algorithmen
Die genetischen Algorithmen (GA) stellen eine weitere Form der Realisierung von EA dar.
Die Information in den Genen wird bei der ursprünglichen, klassischen Form der GA immer
die Ausprägung eines Bits aus der Datenverarbeitung besitzen. Die GA arbeitet dabei meist
nicht mit dem aus den Genen dekodierten Ergebnis, sondern direkt mit den codierten Geninformationen.
Bevor die genetischen Algorithmen an einem Beispiel näher untersucht werden, sollen nun
erst einmal die durch die GA benutzten Operatoren näher erläutert werden.
2.4.1 Vererbungungsmechanismen der genetischen Algorithmen
2.4.1.1 Reproduktion
Die Reproduktion ist der einfachste Operator der GA. Ein Chromosom wird unverändert an
die Population der nächsten Generation vererbt.
2.4.1.2 Mutation
Die Mutation ist nur als Hintergrundoperator der GA definiert. Sie trägt nur zu einem kleinen
Prozentsatz zu der Genveränderung bei. Im Weiteren wird gezeigt werden, daß die Mutation
nicht nur bei den ES, sondern auch in der GA ihre Existenzberechtigung hat.
Die Mutation verändert ein oder mehrere Gene eines Chromosoms bei der Vererbung zufällig.
Ist die Geninformation von der Wertigkeit eines Datenbits, so wird die Mutation in Form einer
Inversion des Datenbits realisiert.
Hier als Beispiel eine Mutation am 4.Gen bei beliebiger Form der Geninformation:
Aus der Sicht der Optimierungstheorie kommt der Mutation die Aufgabe zu, lokale Optima zu überwinden:
Durch zufällige Veränderungen des Erbgutes wird ein
„Einpendeln“ der Evolution bei suboptimalen Lösungen verhindert.
Daß die Mutation den Suchprozeß in der Natur nicht
aktiv steuert, zeigt sich an der Mutationswahrscheinlichkeit eines biologischen Gens. Die Mutationswahrscheinlichkeit für ein Gen in der Natur liegt laut [4] nur
zwischen 5*10-5 und 5*10-7.
Eine übersteigerte Mutation an mehreren Genen zugleich birgt in der GA die Gefahr in sich, daß das System nicht mehr konvergiert und das Auffinden einer stabilen Lösung unmöglich wird.
Seite 29
Kapitel 2: Systeme der künstlichen Intelligenz
2.4.1.3 Inversion
Vorgehensweise bei dem Inversions-Operator:
Umdrehen eines Teilstückes eines Chromosoms und Vererbung des so modifizierten Chromosoms an die nächste Generation.
Inversion der Gene 2 bis 6:
2.4.1.4 Crossover
Vorgehensweise beim Crossover-Operator:
Teilen zweier Chromosomen und Vererbung des über Kreuz zusammengesetzten Chromosoms. Hierbei ist darauf zu achten, daß die Ergebnisse der Neukombination wieder gültige
Chromosomen ergeben (eine Gültigkeitsbetrachtung ist immer abhängig von dem durch das
Chromosom kodierte Problem !).
Crossover nach dem 5. Gen:
Seite 30
Kapitel 2: Systeme der künstlichen Intelligenz
2.4.1.5 Blockung und Entblockung
Vorgehensweise bei der Blockung und der Entblockung:
Zusammenfassen bestimmter Gene zu einer Einheit, deren Teile bei der weiteren Vererbung
bei einer Inversion oder einem Crossover nicht mehr getrennt werden dürfen. Die Entblockung entspricht der Aufhebung der Blockung.
Blockung der Gene 2 bis 6:
Eine starke Einbeziehung der Blockung birgt die Gefahr, den evolutionären Prozeß zum stocken zu bringen und als Lösung nur ein suboptimales lokales Maximum zu erreichen (Sackgasse der Evolution). Regeln für die Blockung / Entblockung sind meist direkt aus einer Erwartungshaltung an die Lösung des genetischen Systems geprägt und schränken die Lösungsvielfalt oft stark ein, fördern jedoch das Konvergenzverhalten der GA und können das Auftreten von ungültigen Lösungen verhindern helfen.
2.4.1.6 Selektion
Vorgehensweise bei der Selektion:
Auswahl der besten Chromosomen. Dies geschieht aufgrund einer Bewertungsfunktion. Diese
bestimmt die Lösungsgüte („Fitness") eines Chromosoms bezogen auf das vorliegende Problem. Ein Selektionsfaktor bestimmt, welcher Anteil der besten Lösungen beim Crossover teilnehmen darf und welche Chromosomen unverändert in die nächste Generation übernommen
werden können (Reproduktion).
Die Lösungsbewertung durch die Fitnessfunktion ist dabei von der Art der Lösungscodierung
in den Genen abhängig. Dies soll im nächsten Kapitel näher erläutert werden.
Seite 31
Kapitel 2: Systeme der künstlichen Intelligenz
2.4.1.7 Lösungsrepräsentation und Codierung, Lösungsbewertung
Ein GA arbeitet, wie bereits auf Seite 29 erwähnt, nicht direkt mit den Entscheidungsgrößen
einer Problemstellung, sondern mit einer Codierung derselben. Die als Bitinformation „1001"
in den Genen kodierte Zahl „9" würde also nicht aus der Bitkette dekodiert werden, sondern
die GA würde direkt mit der Bitkette arbeiten. Die Bitkette stellt somit die Lösungsrepräsentation des Problems in den Genen des GA dar.
Die Art und Weise der Codierung von Parametern eines Problems in den Genen eines GALösungsansatzes ist für eine erfolgreiche Verbesserung dieser Parameter von größter Bedeutung: hierbei wird festgelegt, wie ein GA das gegebene Optimierungsproblem „sieht“.
Die Begriffe „Lösungsrepräsentation“ und „Codierung“ werden zwar häufig synonym verwendet, sind strenggenommen aber nicht identisch. Dies soll am Beispiel der Lösungsbewertung für ein Chromosom (die Bitkette eines Individuums) deutlich gemacht werden.
Es gibt zwei grundsätzliche Möglichkeiten die Anpassung eines Individuums an seine Umwelt
zu bewerten:
 Bestimmung der Anzahl der „fehlerhaften“ Bits beim Vergleich der codierten (als Bitkette
vorliegenden) Lösung und der als Bitkette vorliegenden Zahl der Zielfunktion
Beispiel:
Im Gen sind die Bitwerte
kodiert. Erwünscht wäre die Bitkette:
Damit erhält man die Differenz-Kette
deren Anzahl an „1“-Werten „3“ beträgt.
Da das Individuum an 3 Stellen noch nicht
Gen die Fitness-Bewertung „3“ zugeordnet.
„0 0 1 1 0 0 1 1 1“
„0 1 0 1 0 0 0 1 1“
„0 1 1 0 0 0 1 0 0“
dem Optimum entspricht, wird dem
 Bestimmung des Fitness-Äquivalentes über eine Differenzbildung zwischen der decodierten Lösung aus dem Chromosom und der als Zahl vorliegenden Zielfunktion
Beispiel:
Das Chromosom kodiert den Zahlenwert „15“, erwünscht wäre in diesem Beispiel ein Zustand mit dem Zahlenwert „8“. Damit wird die Fitness-Bewertung mit
15-8 = „7“ ermittelt.
Da die Bitketten ( Lösungsrepräsentation) der Gene zur Differenzbildung decodiert werden
müssen, gibt es mit der Interpretation der Bitwerte verschiedene Möglichkeiten zur Fitnessbewertung der durch das Gen repräsentierten Lösung.
Der sogenannte Gray-Code wird heute häufig anstelle der ursprünglichen binären Codierung
verwendet. Dahinter steht folgende Überlegung:
Kleine Änderungen in den codierten Strukturen (Genotyp) sollten auch nur kleine Änderungen
des Wertes der entsprechenden decodierten Entscheidungsvariablen (Phänotyp) bewirken (um
den Optimierungsprozeß nicht künstlich zu erschweren). Das ist beim traditionellen Binärcode
nicht gewährleistet, wie folgendes aus [3] entnommenes Beispiel zeigt:
Codierung (binär)
011
decodierter Variablenwert
3
Seite 32
Kapitel 2: Systeme der künstlichen Intelligenz
100
4
Obwohl die decodierten Variablenwerte eng beieinander liegen, ist jedes Bit in seiner binären
Codierung verschieden. Die Codierungen der Zahlen „3“ und „4“ haben also eine HammingDistanz (Anzahl der Unterschiedlichen Bits) von „3“.
Dies kann beim Anwenden des Crossover-Operator zu einer unerwünscht starken Differenz
zwischen den decodierten Zahlenwerten der Eltern und ihrer Kinder führen (womit die möglicherweise guten Eigenschaften der Eltern nicht mehr bei ihren Kinder wiederzufinden wären).
Beim Gray-Code werden im Variablenraum benachbarte Zahlenwerte so binär dargestellt, daß
sich diese nur um genau ein Bit unterscheiden. Die Hamming-Distanz der Gray-codierten Variablenwerte „3“ und „4“ beträgt also „1“.
Codierung (Gray)
010
110
decodierter Variablenwert
3
4
Die Überlegenheit von Gray-Code gegenüber einer traditionellen Binärcodierung wurde von
Hollstien [16] festgestellt. Dies gilt aber nur für Anwendungen, in denen eine relativ glatte
Zielfunktionstopologie (ein Beispiel für eine mögliche Zielfunktionstopologie folgt auf der
nächsten Seite) vorliegt, d.h. das ein kleiner Schritt in die Richtung des optimalen Zustandes
auch eine kleine Verbesserung der Bewertung des Chromosoms mit sich bringt.
Ist die Zielfunktionstopologie stark zerklüftet, so kann die beim Crossover zweier binärer Bitketten entstehende „Unruhe" zum Verlassen von lokalen Optima beitragen.
Wie zu sehen war, muß nun die Zielfunktionstopologie bekannt sein, um eine ideale bzw.
erfolgreiche Form der Dekodierung der Bitwerte wählen zu können. Hier wäre die Existenz
einer neutralen Bewertungsfunktion für die in den Genen codierte Bitkette wünschenswert:
Eine neutrale Bewertungsfunktion liegt vor, wenn das gewünschte Ziel der Optimierung ebenfalls in einer beliebigen binären Codierung vorliegt (also schon zu Beginn der Optimierung
bekannt ist) und die Abweichung eines Optimierungsergebnisses über die Anzahl der sich
unterscheidenden Bits berechnet werden kann. Das Ziel der Optimierung wird als „Zielfunktion“ bezeichnet.
Zielfunktion
1001 0110
Gen eines Individuums aus
der Lösungspopulation
1011 0100
Anzahl der abweichenden
Bits (Fitness-Äquivalent)
2
Damit ist klar geworden, daß die Wahl der Problemcodierung und der Lösungsbewertung einen Einfuß auf das Konvergenzverhalten der GA-Realisierung haben kann.
Seite 33
Kapitel 2: Systeme der künstlichen Intelligenz
Die Anwender von GA-Systemen gehen im Allgemeinen so vor, daß sie anhand der zu erwartenden Lösungstopologie zwischen der binären Dekodierung und der Dekodierung mit dem
Gray-Code wählen.
2.4.1.8 Ein „sanftes“ Fehlergebirges einer Lösungstopologie
Das folgende Bild zeigt ein beliebiges Fehlergebirge:
Bei der GA-Spezifizierung wird nun nach folgender Regel vorgegangen:
 Ist dieses Gebirge stark zerklüftet und weist es steile Sprünge auf, so wird meist eine Dekodierung im 2n-Code realisiert.
 Ist das Fehlergebirge - wie im Bild - mit überwiegend stetigen Fehlerübergängen ausgestattet, wird der beim Crossover im Verhalten stetigere Gray-Code zur Interpretation der Bitwerte eines Chromosoms eingesetzt.
Es ist übrigens nicht notwendigerweise so, daß die Bitwerte in den Genen eines Individuums
die Information nur einer einzigen Zahl repräsentieren. Es ist vielmehr so, daß eine das Gen
interpretierende Funktion das Gen in logische Gruppen unterteilen und aus dem Gen somit
mehrere dezimale Zahlenwerte extrahieren kann.
Seite 34
Kapitel 2: Systeme der künstlichen Intelligenz
2.5 Zusammenfassung der Eigenschaften von GA, ES und EP
In der folgenden Tabelle sollen noch einmal die wichtigsten Eigenschaften der GA, der ES
und der GP einander gegenüber gestellt werden:
Kriterium
Abstraktionsebene
Lösungsrepräsentation
Lösungsbewertung
anhand von
Decodierungsfunktion
GA
Individuum (Genotyp)
ursprünglich binär;
auch andere
skalierter
Zielfunktion
meist erforderlich
ES
Individuum (Phänotyp)
reell
EP
Population
Zielfunktion
Zielfunktion
(z.T. skaliert)
meist nicht
erforderlich
stochastisch,
auslöschend
einziger
Suchoperator
nicht vorhanden
nicht erforderlich
deterministisch,
Selektionsmechanismus stochastisch,
erhaltend
auslöschend
Hintergrundoperator Haupt-Suchoperator
Mutation
Crossover
Haupt-Suchoperator
Operatorenfolge je
Generation
 Selektion
 Replikation
 Crossover
 Mutation
 Evaluation
1 (Variablen)
Optimierungsebenen
nur wichtig für
Selbstadaptivität
 Replikation
 Crossover
 Mutation
 Evaluation
 Selektion
2 (Variablen und
Strategieparameter)
reell




Replikation
Mutation
Evaluation
Selektion
EP: 1
(R)Meta-EP: 2 (Variablen und
Strategieparameter)
(Entnommen aus [3] Seite 192)
Zu sehen ist, daß die aufgeführten Optimierungsstrategien verwandte Realisierungen der gleichen Idee darstellen; dieser Meinung sind die Mitglieder der verschiedenen „Schulen“ leider
nicht. Deshalb werden oft für die gleichen Vorgänge und Objekte verschiedene Begriffe gewählt. Innerhalb dieser Arbeit wurde versucht, wo immer dies möglich und sinnvoll erschien,
gleiche Vorgänge mit dem gleichem Namen zu benennen.
So gibt es z.B. bei den genetischen Algorithmen den Begriff des „Chromosoms“ für eine Kette von Geninformation nicht, statt dessen wird leicht schwerfällig der Begriff des als Phänotyp
(decodierte Lösung  die dezimale Zahl) codierten Genotyps (codierte Lösung  die Bittkette) benutzt. In dieser Arbeit wird aber trotzdem auch bei den genetischen Algorithmen von
Chromosomen gesprochen, wenn eine Kette von Geninformationen gemeint ist.
In den folgenden Kapiteln sollen nun MATLAB-Realisierungen zu einigen der eingeführten
Optimierungsstrategien vorgestellt werden.
Seite 35
Kapitel 3: Das Travelling Salesman Problem
Kapitel 3: Das Travelling Salesman Problem
Ein sehr häufig untersuchtes Problem aus dem Bereich des operations research ist das Travelling Salesman Problem (TSP):
Ein Handlungsreisender soll nacheinander auf einer kostenminimalen Tour n Städte besuchen,
wobei jede Stadt nur einmal aufgesucht werden darf. Die Kosten sollen hier durch die Weglänge der Tour bestimmt werden. Außerdem soll es sich um ein symmetrisches Problem handeln, d.h. die Entfernung zwischen zwei Städten ist richtungsunabhängig.
Bei der Realisierung diese Beispiels wurde eine (+)-ES-Realisierung (siehe Seite 24) gewählt. Das zugehörige MATLAB-Programm ES_TSP.M befindet sich auf der Diskette am
Ende dieser Arbeit, der Quelltext der MATLAB-Realisierung ist ab Seite 134 abgedruckt.
Für die Realisierung wurde folgende Kodierung des Problems festgelegt:
 Die Städte dieser Reisestrecke (der Tour) wurden mit Index-Nummern versehen. Zu den
Städten sind die X-Y-Lagekoordinaten bekannt; diese sind in einer Liste gespeichert.
 Das Chromosom eines Individuums enthält in einem MATLAB-Zahlenvektor nacheinander die Indizes der zu besuchenden Städte.
 Die Reiseroute folgt den Städte-Indizes und kann mit Kenntnis der X-Y-Koordinaten der
Städte in ihrer Routenlänge berechnet werden.
 Mehrere Individuen konkurrieren dabei miteinander um die kürzeste Reiseroute.
 Die Routenlänge wird als Fitnesswert behandelt (kürzere Route -> bessere Fitness).
 Eine Veränderung der Route wird durch 4 Mutationsoperationen durchgeführt, die auf die
Chromosomen der Individuen angewandt werden. Diese Mutationsoperatoren werden im
nächsten Kapitel genauer beschrieben.
In Anlehnung an die (+)-ES-Beschreibung auf Seite 24 soll beim TSP wie folgt vorgegangen werden:
 Zufällige Auswahl von einer vom Benutzer vorzugebenden Zahl von Eltern für die 4 realisierten, speziell auf das Problem des TSP angepaßten Mutationen
 Kopieren der ausgewählten Eltern und Mutation der im Chromosom gespeicherten StädteIndizes (dies sind von nun an die Nachkommen)
 Bewerten der Nachkommen mit einer Fitnessfunktion
 Variation der Nachkommen Schrittweiten mit einem der Vektoren des Tripels [1.5 1/1.5 1]
 Die besten aus dem Genpool der Eltern und der Nachkommen werden die Eltern einer neuen Generation
Seite 36
Kapitel 3: Das Travelling Salesman Problem
3.1 Die Mutations-Operatoren des TSP
Zur Lösung des TSP wurden aus [7] folgende 4 Mutations-Operatoren entnommen und in der
MATLAB-Lösung angewendet:
Der 1. Mutations-Operator „Inversion“
Beispiel: Inversion des Tourstückes 2-3-4-5 nach 5-4-3-2
Der Mutationsfaktor Inversion bewirkt die geringste Qualitätsänderung, da nur zwei Verbindungen der Elterntour aufgebrochen und nur zwei neue Verbindungen geschaffen werden.
Ablauf der Inversions-Mutation als Meta-Code angegeben:
Für i Individuen folgendes Ausführen
Ermittle zufällig ein Elter-Individuum (die „Tour")
Ermittle die Stadt, bei der die Inversion starten soll (Stadt-Index 1)
Ermittle die Stadt, bei der die Inversion enden soll (Stadt-Index 2)
Erzeuge ein Kind dieses Individuums, dessen zuvor zufällig ausgewähltes Tourstück
invertiert wird
Verändere zufällig die vererbte Schrittweite dieses Kindes um einen Faktor, der aus
dem Bereich 1 oder 1,5 oder (1/1,5) stammt, wobei dieser Faktor nicht größer als „1"
werden kann
Nächstes Individuum mutieren bis i erreicht
Die aktuelle Schrittweite des Elters hat bei der Mutation Inversion einen Einfluß auf die Anzahl der zu invertierenden Gene im Chromosom. Dazu wird die maximal mögliche Entfernung der Stadt mit dem Index 2 von der Stadt mit dem Index 1 mit einem Schrittweite-Wert
SW<=1 multipliziert.
Matlab-Lösung der Inversion (Schrittweiten-Einfluß ist markiert):
for i=1:round((Individuen*Inversion)/100)
Tour
= round((rand*Individuen)+0.5);
Stadt1 = round((rand*(PunkteZahl-1))+0.5);
Stadt2 = round((rand*SW(Tour)*(PunkteZahl-Stadt1)+0.5)+Stadt1);
Population_Kinder(:,p_zeiger)=Population_Eltern(:,Tour);
Population_Kinder(Stadt1:Stadt2,p_zeiger)= ...
rot90(Population_Eltern(Stadt1:Stadt2,Tour),2);
% Jetzt die Schrittweite zufaellig aendern
% SW_Change: 0 oder 1 oder 2
% 0 -> /1.5
1 -> *1.5
2 -> unveraendert
SW_Change=floor(rand*2+0.5);
if
SW_Change==0 SW(p_zeiger)=SW(Tour)/1.5;
elseif SW_Change==1 SW(p_zeiger)=SW(Tour)*1.5;
else
SW(p_zeiger)=SW(Tour);
end;
p_zeiger = p_zeiger+1;
Seite 37
Kapitel 3: Das Travelling Salesman Problem
end % for i
Seite 38
Kapitel 3: Das Travelling Salesman Problem
Der 2. Mutations-Operator „Insert“
Beispiel: Einfügen der Stadt Nr. 2 zwischen den Städten 5 und 6
Beim Mutationsfaktor Insert handelt es sich um den Operator, der nach der Inversion die geringste Qualitätsänderung bewirkt. Es werden maximal drei Verbindungen der bestehenden
Tour aufgebrochen und entsprechend viele neue Verbindungen geschaffen.
Ablauf der Insert-Mutation als Meta-Code angegeben:
Für i Individuen folgendes Ausführen
Ermittle zufällig ein Elter-Individuum (die „Tour")
Ermittle die Stadt, die dem Gen entnommen werden soll
Ermittle die Stelle, an der das entnommene Gen eingefügt werden soll
Verhindere durch einen Algorithmus, daß die Stadt an der ursprüngliche Stelle eingefügt wird
Verändere zufällig die vererbte Schrittweite dieses Kindes um einen Faktor, der aus
dem Bereich 1 oder 1,5 oder (1/1,5) stammt, wobei dieser Faktor nicht größer als „1"
werden kann
Nächstes Individuum mutieren bis i erreicht
Die aktuelle Schrittweite des Elters hat bei der Mutation Insert einen Einfluß auf die Auswahl
des Ziel-Indexes an dem das entnommene Gen eingefügt werden soll. Dazu wird die maximal
mögliche Entfernung des Ziels mit einem Schrittweite-Wert SW<=1 multipliziert.
Matlab-Lösung des Insert (Schrittweiten-Einfluß ist markiert):
for i=1:round((Individuen*Insert)/100)
Tour = round((rand*Individuen)+0.5);
Stadt= round((rand*(PunkteZahl))+0.5);
Ziel = Stadt+round((rand*SW(Tour)*(PunkteZahl-Stadt-1))+0.5);
if Ziel==Stadt
if Stadt>(HalbePunkteZahl) Ziel=Stadt-1;
else
Ziel=Stadt+1;
end %if Stadt>(PunkteZahl/2)
end %if Ziel==Stadt
Population_Kinder(:,p_zeiger)= ...
str_del(Population_Eltern(:,Tour),Stadt,1);
Population_Kinder(:,p_zeiger)=str_in(Population_Kinder(:,p_zeiger), ...
Population_Eltern(Stadt,Tour), Ziel);
% Jetzt die Schrittweite zufaellig aendern
% SW_Change: 0 oder 1 oder 2
% 0 -> /1.5
1 -> *1.5
2 -> unveraendert
SW_Change=floor(rand*2+0.5);
if
SW_Change==0 SW(p_zeiger)=SW(Tour)/1.5;
elseif SW_Change==1 SW(p_zeiger)=SW(Tour)*1.5;
else
SW(p_zeiger)=SW(Tour);
end;
p_zeiger=p_zeiger+1;
end % for i
Seite 39
Kapitel 3: Das Travelling Salesman Problem
Der 3. Mutations-Operator „Moving“
Beispiel: Verschiebung des Tourstückes 2-3-4-5
Bei der Verschiebung eines Tourstückes werden drei Verbindungen der bestehenden Elterntour aufgetrennt und drei neue Verbindungen hergestellt.
Ablauf der Moving-Mutation als Meta-Code angegeben:
Für i Individuen folgendes Ausführen
Ermittle zufällig ein Elter-Individuum (die „Tour")
Ermittle die Anzahl der Städte, die im Gen verschoben werden sollen
Ermittle die Stelle, ab der die Gene dem Chromosom entnommen werden sollen
Ermittle die Stelle, an der die entnommenen Gene eingefügt werden sollen
Verändere zufällig die vererbte Schrittweite dieses Kindes um einen Faktor, der aus
dem Bereich 1 oder 1,5 oder (1/1,5) stammt, wobei dieser Faktor nicht größer als „1"
werden kann
Nächstes Individuum mutieren bis i erreicht
Die aktuelle Schrittweite des Elters hat bei der Mutation Moving einen Einfluß auf die Anzahl
der Städte, die im Gen verschoben werden sollen. Dazu wird die maximal mögliche Anzahl an
zu verschiebenden Städten mit einem Schrittweite-Wert SW<=1 multipliziert.
Matlab-Lösung des Moving (Schrittweiten-Einfluß ist markiert):
for i=1:round((Individuen*Moving)/100)
Tour = round((rand*Individuen)+0.5);
Anzahl= round(rand*SW(Tour)*(PunkteZahl-1)+0.5);
Stadt = round((rand*(PunkteZahl-Anzahl))+0.5);
Ziel = round((rand*(PunkteZahl-Anzahl))+0.5);
Population_Kinder(:,p_zeiger)= ...
str_del(Population_Eltern(:,Tour),Stadt,Anzahl);
Population_Kinder(:,p_zeiger)=str_in(Population_Kinder(:,p_zeiger), ...
Population_Eltern(Stadt:(Stadt+Anzahl-1),Tour), Ziel);
% Jetzt die Schrittweite zufaellig aendern
% SW_Change: 0 oder 1 oder 2
% 0 -> /1.5
1 -> *1.5
2 -> unveraendert
SW_Change=floor(rand*2+0.5);
if
SW_Change==0 SW(p_zeiger)=SW(Tour)/1.5;
elseif SW_Change==1 SW(p_zeiger)=SW(Tour)*1.5;
else
SW(p_zeiger)=SW(Tour);
end;
p_zeiger=p_zeiger+1;
end % for i
Seite 40
Kapitel 3: Das Travelling Salesman Problem
Der 4. Mutations-Operator „Exchange“
Beispiel: Vertauschen der Städte Nr. 2 und Nr.5
Der Vertauschungsoperator bewirkt die stärkste Qualitätsänderung. Es werden bis zu vier
Verbindungen der bestehenden Tour aufgebrochen und entsprechend viele neue Verbindungen
geschaffen.
Ablauf der Exchange-Mutation als Meta-Code angegeben:
Für i Individuen folgendes Ausführen
Ermittle zufällig ein Elter-Individuum (die „Tour")
Ermittle eine Stadt, die getauscht werden soll (Stadt-Index 1)
Ermittle eine weitere Stadt, die getauscht werden soll (Stadt-Index 2)
Verhindere durch einen Algorithmus, daß die beiden Städte ein und dieselbe sind
Verändere zufällig die vererbte Schrittweite dieses Kindes um einen Faktor, der aus
dem Bereich 1 oder 1,5 oder (1/1,5) stammt, wobei dieser Faktor nicht größer als „1"
werden kann
Nächstes Individuum mutieren bis i erreicht
Die aktuelle Schrittweite des Elters hat bei der Mutation Exchange einen Einfluß auf die maximale Entfernung der Indexe der beiden von der Mutation betroffenen Städte. Dazu wird die
maximal mögliche Entfernung der Stadt mit dem Index 2 von der Stadt mit dem Index 1 mit
einem Schrittweite-Wert SW<=1 multipliziert.
Matlab-Lösung des Exchanges (Schrittweiten-Einfluß ist markiert):
for i=1:round((Individuen*Exchange)/100)
Tour=round((rand*Individuen)+0.5);
Stadt1=round((rand*PunkteZahl)+0.5);
Stadt2=Stadt1+round((rand*SW(Tour)*(PunkteZahl-Stadt1-1))+0.5);
if Stadt1==Stadt2
if Stadt1>(HalbePunkteZahl) Stadt2=Stadt1-1;
else
Stadt2=Stadt1+1;
end % if Stadt1>(PunkteZahl/2)
end % if Stadt1==Stadt2
Population_Kinder(:,p_zeiger)=Population_Eltern(:,Tour);
Population_Kinder(Stadt1,p_zeiger)=Population_Kinder(Stadt2,p_zeiger);
Population_Kinder(Stadt2,p_zeiger)=Population_Eltern(Stadt1,Tour);
% Jetzt die Schrittweite zufaellig aendern
% SW_Change: 0 oder 1 oder 2
% 0 -> /1.5
1 -> *1.5
2 -> unveraendert
SW_Change=floor(rand*2+0.5);
if
SW_Change==0 SW(p_zeiger)=SW(Tour)/1.5;
elseif SW_Change==1 SW(p_zeiger)=SW(Tour)*1.5;
else
SW(p_zeiger)=SW(Tour);
end;
p_zeiger=p_zeiger+1;
end % for i
Seite 41
Kapitel 3: Das Travelling Salesman Problem
Seite 42
Kapitel 3: Das Travelling Salesman Problem
Das Ausgabefenster des MATLAB-Programmes ES_TSP.M:
Nummer Beschreibung
1
Dieses Fenster stellt die Entwicklung der Weglänge über der Generationenzahl dar.
Dabei wird die durchschnittliche Weglänge (entspricht der durchschnittlichen Fitness) als grüne Kurve, und die Weglänge der bis zu diesem Zeitpunkt besten Lösung als gelbe Kurve dargestellt (hier wegen des besseren Kontrastes in Blau dargestellt).
Im Kopf dieses Fensters werden dem Benutzer Statusmeldungen übermittelt.
2
In diesem Fensterteil wird der Weg, den die bis zu diesem Zeitpunkt beste Lösung
beschreibt, als Kurve dargestellt.
3
Mitteilung über die durchschnittliche Weglänge der gesamten Eltern-Generation.
Mean Stepsize gibt den durchschnittlichen Wert der Mutations-Schrittweite aller
Individuen am Ende der letzen Generation an. Dieser Wert kann größer als „1"
werden, obwohl beim einzelnen Individuum nur Werte bis „1" zulässig sind. Dies
liegt daran, daß bei der Berechnung der Schrittweite unter anderem mit dem Faktor
1.5 gearbeitet wird und dabei Schrittweiten größer „1" entstehen können. Diese
größeren Werte werden am Anfang jeder Generationsschleife auf den Maximalwert
von „1“ begrenzt. Für das Beurteilen einer Tendenz bei der Schrittweitenentwicklung ist es jedoch interessanter, den berechneten Wert vom Ende der letzten Generation zu sehen.
4
Pop-Up Menü, um zwischen 3 im Programm vordefinierten Wegen (Touren) und
einem benutzerdefinierten Weg als Aufgabe zu wählen. Bei den vordefinierten
Wegen ist als Anhaltspunkt der bisher als beste Lösung ermittelte Weg in Metern
mitvermerkt. Bei der Auswahl des benutzerdefinierten Weges gestattet ein weiteres
Seite 43
Kapitel 3: Das Travelling Salesman Problem
5
6
7
8
9
10
11
12
13
14
15
16
17
18
MATLAB-Fenster die Eingabe von Städte-Koordinaten mit der Maus. Die rechte
Maustaste setzt dabei die Koordinaten der letzten Stadt der Reise
(mindestens 3 Städte müssen definiert werden)
Schieberegler für die Abbruchbedingung „letzte zu simulierende Generation“
Erklärung unter Punkt 18 dieser Liste
Schieberegler für die Mutations-Funktion „Moving“
Schieberegler für die Mutations-Funktion „Inversion“
Schieberegler, der die Anzahl der simulierten Eltern bestimmt.
Schieberegler für die Mutations-Funktion „Exchange“
Schieberegler für die Mutations-Funktion „Insert“
Button, der die Simulation von einer Generation startet
Button, der die Simulation startet
Button, der die Simulation anhält
Button, der ein Info-Fenster öffnet
Button, der das Programm neu startet
Button, der das Programm beendet
Button, der das Programm neu startet, den Zufallsgenerator von MATLAB aber auf
den letzten Startwert zurücksetzt.
Pop-Up Menü, um das Terminierungs-Verhalten beeinflussen zu können.
"Stop when done" beendet die Generationen-Iteration wenn
 die Generationenzahl die am Slider „Last Generation" eingestellte Zahl erreicht
hat
 die Fitness des besten Individuums die mittlere Fitness der Individuen der aktuellen Generation erreicht hat
"Stop never" beachtet diese Abbruchbedingungen nicht.
Bei den Mutations-Faktoren „Moving“, „Inversion“, „Exchange“ und „Insert“ entsprechen
100% einer Generierung von jeweils der gleichen Anzahl von mutierten Individuen wie beim
Schiebeschalter „Individuen“ eingestellt wurde (20 Individuen und 4 mal 100 % entsprechen
also 80 mutierten Nachkommen).
Die Selektion der Besten
Es wird immer aus den Individuen der Elterngeneration und der Nachkommengeneration
durch Selektion der besten Lösungen die nächste Generation gebildet.
Um die Selektion durchführen zu können, muß die Fitness des einzelnen Individuums bestimmt werden. Da die Gene eines Individuums dessen Weg von Stadt zu Stadt beschreiben,
kann aus den Genen die Gesamtlänge der Reiseroute berechnet werden (es wird der direkte
Weg zwischen den Städten mit Hilfe des Satzes von Pythagoras ermittelt). Beim Vergleich
von zwei Individuen entspricht der kürzere Weg einer besseren Fitnessbewertung. Die Individuen brauchen nun nur noch nach aufsteigender Weglänge sortiert werden, um die ersten Individuen (im angenommenen Fall: die ersten 20 Individuen) in die neue Elterngeneration
übernehmen zu können.
Durch die Selektion der Besten steigt die durchschnittliche „Fitness“ der neuen Generation
solange an, bis ein lokales oder globales Maximum erreicht wird.
Seite 44
Kapitel 3: Das Travelling Salesman Problem
Im folgenden Bild ist ein Ausschnitt aus dem Simulationslauf für ein 84-Städte-Problem
(mögliche Kombinationen = Fakultät 84  3.3 * 10126 Wege) mit einer (60+240)-ES dargestellt. Abgebildet sind die jeweils besten Lösungen zu verschiedenen Entwicklungsstufen
(Generationen):
Seite 45
Kapitel 3: Das Travelling Salesman Problem
3.2 Zur Programmierung des MATLAB-Programms ES_TSP.M
Vorgaben für die Programmierung:
Da Matlab keine Unterprogramm-Aufrufe unterstützt und die Realisierung von Unterfunktionen als eine schnell unübersichtlich werdende Menge von M-Files vermieden werden sollte,
wurde folgende Realisierung gewählt (auf diese Weise programmiert MATHWORKS auch
alle Toolbox-Funktionen mit interaktiver, graphischer Oberfläche):
Das Programm wurde als Funktion realisiert, die sich selbst rekursiv aufrufen kann. Bei so
einem rekursiven Selbstaufruf wird dem Programm ein Parameter in Form eines Strings übergeben, anhand dessen die Ausführung einer Unterfunktion (eine „Action“) angefordert werden
kann.
Beispiel:
>> ES_TSP(‘Beenden’)
Wird ES_TSP ohne einen Parameter aufgerufen, so wird angenommen, daß ein Benutzer das
Programm starten will und der Aufruf wird durch das Programm in „ES_TSP(‘Start’)“ verändert.
Für den Benutzer ist die Kenntnis der Actions unnötig, da sie nur dazu dienen, das Programm
als eine Sammlung von möglichst wenigen, verschiedenen Files zur Verfügung zu stellen.
Um das Programm für den Programm-lesenden besser verständlich zu machen, soll hier trotzdem kurz auf die vorhandenen Actions eingegangen werden:
Action
Art der Nutzung
Start
Wird aufgerufen, wenn ES_TSP ohne Action gestartet wird.
Initialisiert Variablen, öffnet das Ausgabefenster, legt die Buttons und
Slider an und ruft die Action „SetDefault“ auf.
Wird von der Action „Start“ und „New“ aufgerufen und belegt verschiedene Variablen mit Default-Werten.
Wird während der Simulation von der Action „Loop“ aufgerufen und
zeichnet die Weglängen über der Generationenzahl und den Weg des
derzeit besten Individuums im Ausgabefenster neu.
Die Gene aller Individuen werden mit einer vorgegebenen, für alle
gleich gewählten Städte-Indexfolge (Reiseroute) vorbelegt
-> Ausgangssituation vor Start
Wird immer dann aufgerufen, wenn der Benutzer den Pop-Up „Stop“
verändert. Setzt die Variable „CareFor“.
Wird immer dann aufgerufen, wenn der Benutzer den Pop-Up „Route“
verändert. Ruft entsprechend der Auswahl durch den Benutzer die Actions „ReiseKreis“, „ReiseAE“, „ReiseBE“ oder „ReiseBenutzer“ auf.
Die von diesen Actions übergebene Reiseroute wird mit der Action
„ReiseMatrix“ allen Individuen übergeben und mit der Action „WegeBerechnen“ wird allen Individuen ein erster Fitness-Wert zugeordnet.
Belegt die Reiseroute mit einer kreisförmigen Reiseroute vor. Die Xund Y-Koordinaten dieser Route sind dabei als Konstanten vordefiniert. Es handelt sich bei dieser Reiseroute um ein 12-Städte Problem
SetDefault
Redraw
ReiseMatrix
SetCareForClausel
SetReise
ReiseKreis
Seite 46
Kapitel 3: Das Travelling Salesman Problem
ReiseAE
ReiseBE
ReiseBenutzer
SetPop
SetMaxGen
SetMoving
SetExchange
SetInsert
SetInversion
Go
Stop
WegeBerechnen
New
Step
Restart
Loop
Info
InfoMore
InfoDone
(diese Reise diente hauptsächlich zu Programmvalidierung).
Belegt die Reiseroute mit einer Reiseroute, die die Buchstabenfolge
„AE“ darstellt, vor. Die X- und Y-Koordinaten dieser Route sind dabei
als Konstanten vordefiniert. Es handelt sich bei dieser Reiseroute um
ein 27-Städte Problem.
Belegt die Reiseroute mit einer Reiseroute, die die Buchstaben „BE“
darstellt, vor. Die X- und Y-Koordinaten dieser Route sind dabei als
Konstanten vordefiniert. Es handelt sich bei dieser Reiseroute um ein
84-Städte Problem.
Ermöglicht es dem Benutzer, eine eigene Reiseroute mit der Maus festzulegen. Es müssen mindestens 3 Städte definiert werden, wobei ein
markieren einer Stadt mit der rechten Maustaste die Definition von
zusätzlichen Städten beendet.
Wird aufgerufen, wenn der Benutzer am Slider „Individuen“ eine neue
Anzahl von Individuen für den Simulationslauf einstellt.
Wird aufgerufen, wenn der Benutzer am Slider „Last Generation“ eine
neue Anzahl für die Abbruchbedingung der letzten zu simulierenden
Generation einstellt. Diese Abbruchbedingung wird nur beachtet, wenn
am Pop-Up „Stop“ die Option „When done“ eingestellt worden ist.
Wird aufgerufen, wenn der Benutzer am Slider „Moving“ eine neue
Wahrscheinlichkeit für die Moving-Mutation einstellt.
Wird aufgerufen, wenn der Benutzer am Slider „Exchange“ eine neue
Wahrscheinlichkeit für die Exchange-Mutation einstellt.
Wird aufgerufen, wenn der Benutzer am Slider „Insert“ eine neue
Wahrscheinlichkeit für die Insert-Mutation einstellt.
Wird aufgerufen, wenn der Benutzer am Slider „Inversion“ eine neue
Wahrscheinlichkeit für die Inversions-Mutation einstellt.
Wird aufgerufen, wenn der Benutzer den „Go“-Button betätigt. Diese
Action belegt verschiedene Variablen vor und startet über die Action
„Loop“ die Simulation von Generationen.
Hält die Simulation von Generationen durch die Action „Loop“ am
Ende eines Generationszyklus an.
Berechnet die Weglängen der Reiserouten aller zur Zeit vorhandenen
Individuen.
Setzt das Programm auf die Anfangswerte zurück, wobei der Zufallszahlengenerator nicht verändert wird.
Startet die Simulation von einer Generation und stoppt danach wieder.
Setzt das Programm auf die Anfangswerte zurück, wobei der Zufallszahlengenerator auf den Wert, den er beim letzten Start hatte, zurückgesetzt wird.
Simuliert die Evolution über mehrere Generationen, bis eine Endbedingung eintritt:
- Benutzer betätigt „Stop“-Button
- Anzahl der gewünschten Generationen wird überschritten
- Fitness des besten Individuums entspricht der durchschnittlichen Fitness aller Individuen
Öffnet ein erstes Fenster mit Erklärungen.
Schaltet zwischen zwei Fenstern mit Erklärungen um.
Schließt alle Fenster mit Erklärungen.
Seite 47
Kapitel 3: Das Travelling Salesman Problem
Done
Beendet das Programm.
Seite 48
Kapitel 3: Das Travelling Salesman Problem
Die eigentliche Optimierung findet beim MATLABProgramm „ES_TSP.M“ in dem Programmteil „Loop“ statt.
Dieser wird nach Betätigen des „GO“- oder des „STEP“Buttons ausgeführt.
Die derzeitige Eltern-Generation wird den vier realisierten
Mutations-Arten unterzogen (bei der ersten Generation sind
die Gene der Eltern-Generation zuvor von einem Zufallsgenerator gebildet worden).
Mit Hilfe des Zufallsgenerators werden jeweils die Individuen (Touren) und die beteiligen Städte für die Mutation
ausgewählt.
Besonderheiten in der Programmierung:
Moving / Insert:
Es wurden die beiden Funktionen „STR_DEL.M“ und
„STR_IN.M“ bereitgestellt, die aus Zahlenvektoren Teilstücke entfernen bzw. in diese einfügen können.
Inversion:
Die Inversion wurde durch zweimaliges Anwenden des Befehles „ROT90“ realisiert. Dadurch wird ein Teilstück eines
Zahlenvektors in der gewünschten Weise invertiert.
Für die Selektion der besten Individuen muß erst einmal für
alle Individuen die Fitness bestimmt werden. Dazu wird mit
den in den Genen gespeicherten Städte-Indexen und den zu
den Städten gehörenden Koordinaten der zurückgelegte Reiseweg berechnet.
Ein kürzerer Weg entspricht dabei einer besseren FitnessBewertung.
SimulationsLoop
GenerationsCntr+
1
Mutation
"Exchange"
Mutation
"Moving"
Mutation
"Inversion"
Mutation
"Insert"
Selektion: Die
Besten werden
Eltern
Besten Weg
zeichnen
Abbruch
?
Nein
Ja
Weiter
Die besten Kinder werden nun die Eltern der neuen Generation.
Die Generations-Simulation wird solange fortgesetzt, bis eine der folgenden Bedingungen
eintrifft ( Abbruch):
 Die Generationenzahl erreicht die vom Benutzer bestimmte Obergrenze.
 Die Fitness des besten Individuums wird von der mittleren Fitness der ganzen Population
eingeholt (dann muß nicht der kürzeste Weg ermittelt worden sein, das System ist aber bei
einem lokalen Minimum angelangt -> Ratlosigkeit des Systems).
Dies alles unter der Voraussetzung, daß der Benutzer eine Beachtung dieser Abbruchbedingungen erlaubt hat.
Eine weitere (triviale) Abbruchbedingung ist:
Seite 49
Kapitel 3: Das Travelling Salesman Problem
 Der Benutzer bricht die Simulation mit dem „Stop“-Button ab
3.3 Konvergenzverhalten des MATLAB TSP
Das Konvergenzverhalten über der Generationen-Zahl kann bei dieser ES-Realisierung wie
folgt beschrieben werden:
Anfangs bringt jede neue Generation eine starke Verbesserung der Fitness mit sich. Je besser
die einzelnen Individuen an die mathematische Umwelt angepaßt sind (d.h. je näher die Lösung an einem Optimum liegt), um so schwerfälliger ist die Entwicklung des Genpools zu
besseren Lösungen hin.
In der vorgestellten Realisierung des TSP wird die Schrittweite des Nachkommens anhand
einer Zufallszahl aus dem Tripel [0 1 2] mit einem Faktor aus dem Tripel [1.5 1/1.5 1] willkürlich verändert.
Versuche, bei denen von diesem Nachkommen drei Kopien angelegt wurden und jeder dieser
Nachkommen mit einem anderen Faktor aus dem Faktoren-Tripel belegt wurde, brachten erstaunlicherweise keine Beschleunigung des Konvergenzverhaltens.
Da sich jedoch der Rechenzeitaufwand im Bezug auf die Anzahl der Nachkommen in der
nächsten Generation verdreifachte, wurde auf diese Realisierung verzichtet.
Folgende Kurve zeigt die Entwicklung der jeweils besten Lösung einer Generation über der
Generationenzahl:
Dieses Konvergenzverhalten in Form einer e-Funktion ist nach Aussagen in [1] und [3] typisch für evolutionäre Lösungsansätze mit stochastischen Algorithmen.
Dies wird erklärlich, wenn man sich vor Augen führt, daß e-Funktionen in natürlichen Vorgängen eine bedeutende Rolle spielen und es ja gerade ein Grundgedanke der GA und der ES
ist, natürliche Vorgänge der Evolution für die Problemlösung nachzubilden.
Die Mitglieder der AVIDA-Gruppe gehen in [18] sogar davon aus, daß die Lösungskurven des
Konvergenzverhaltens von Systemen mit evolutionären Algorithmen ein fraktales Verhalten
aufweisen (d.h., daß sich die Form der Kurve bei Betrachtung eines Ausschnittes mit höherer
Auflösung, im Kleinen wiederholt).
Seite 50
Kapitel 3: Das Travelling Salesman Problem
3.4 Abbruchbedingung des MATLAB TSP
Die Berechnung von neuen Generationen zur Lösung des TSP wird durch das Programm beendet, wenn die durchschnittliche Fitness der Population die Fitness des Besten der Population erreicht hat. In diesem Fall haben meist alle Individuen die gleiche Städte-Folge in Ihrem
Chromosom kodiert und die Lösungsvielfalt hat somit stark abgenommen.
Natürlich könnten durch Mutation noch bessere Lösungen entstehen; der Ausgleich in den
Fitness-Werten kann aber als „Ratlosigkeit“ der Population gegenüber einer weitergehenden
Verbesserung der Anpassung (Lösungsverbesserung) aufgefaßt werden und stellt damit einen
brauchbaren Ansatz für eine Abbruchbedingung dar.
Seite 51
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
4.1 Ein binärer genetischer Algorithmus
Der in [3] von Nissen beschriebene binäre genetische Algorithmus wurde als MATLABLösung realisiert.
Der Algorithmus von [3] lautet als Pseudo-Code realisiert folgendermaßen (der MATLABCode findet sich im Anhang und auf der beigelegten Diskette):
10
20
30
40
50
60
70
80
durch
90
100
110
120
130
140
150
Start
Generiere Startpopulation binär codierter Lösungen auf zufällige Weise
Wiederhole bis Abbruchbedingung erfüllt
Bewerte alle Individuen anhand der Fitnessfunktion
Neue Population als leere Menge anlegen
Wiederhole solange neue Population noch unvollständig
Wähle zwei Individuen mit fitnessproportionalen
Wahrscheinlichkeiten als Eltern aus
Führe mit Wahrscheinlichkeit Pc (Benutzervorgabe) ein Crossover
Mutiere (invertiere) jedes Bit der so entstandenen Nachkommen
mit der Wahrscheinlichkeit Pm (Benutzervorgabe)
Füge beide Nachkommen zur neuen Population hinzu
Schleifenende für unvollständige Population
Alte Population = neue Population (* nächste Generation *)
Schleifenende für erfüllte Abbruchbedingung
Ergebnisausgabe
Stop
Die Parameter Pc und Pm müssen vom Benutzer zu Beginn der Simulation vorgegeben werden.
Über die Art und Weise, wie das in der Zeile 80 erwähnte Crossover durchgeführt werden
soll, wird keine Aussage getroffen.
Auf die realisierten Varianten wird im Kapiteln 4.1.2 Vergleich der angewandten Crossover-Methoden näher eingegangen.
Bei der Realisierung wurde auf eine Ergebnisausgabe erst am Ende der Optimierung zugunsten einer ständig am Ende einer Generation aktualisierten Ergebnisdarstellung verzichtet.
Seite 52
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
4.1.1 Die Fitness-Funktion des binären genetischen Algorithmus
Die Fitnessfunktion ermittelt aus den Genen eines Individuums einen Zahlenwert, der die
Eignung dieses Individuums für die gewählte mathematische Welt beschreibt. Sie ist vom
Anwender des GA bereitzustellen. In der Fitnessfunktion formuliert der Anwender des GA
seine Zielvorstellungen und seine Erwartungen an das Ergebnis der vom GA durchzuführenden Parameter-Optimierung.
In GA_BIN.M ist die Fitness des einzelnen Genes der Ähnlichkeit des Gen-Bitmusters mit
dem Vorgabemuster äquivalent. Ein kleinerer Zahlenwert repräsentiert hierbei einen besseren
Fitnesswert.
Es bieten sich, wie schon im Kapitel 2.4.1.7 Lösungsrepräsentation und Codierung, Lösungsbewertung erläutert, zwei Möglichkeiten der Realisierung:
1. Differenzbildung zwischen der aus dem Gen decodierten Zahl mit der decodierten Zahl des
Vorgabemusters
2. Zählen der am gleichen Locus unterschiedlichen Bits zwischen dem Individuum und dem
Vorgabemuster (dem Ziel der Optimierung)
Um sich die Decodierung und Probleme mit der Lösungsrepräsentanz zu ersparen, wurde die
zweite Möglichkeit, das Zählen der unterschiedlichen Bits, realisiert.
Ein Individuum ist somit am Besten an eine Umgebung angepaßt, wenn die in seinen Genen
gespeicherten Bitinformationen einem vorgegebenen Bitmuster entsprechen.
Seite 53
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
4.1.2 Vergleich der angewandten Crossover-Methoden
Wie im Kapitel zuvor erwähnt, können zwei Crossover-Methoden ausgewählt werden. Die
folgende Grafik zeigt die beiden Methoden für 10 Individuen und bei 100 prozentigem
Crossover (auf eine vollständigen Darstellung der Elternbeziehungen beim Crossover der Methode 2 wurde zugunsten einer besseren Übersichtlichkeit verzichtet).
 Methode 1: „Die Zwei-Partner-Methode“
Hierbei werden die Individuen, die die Elterngeneration bilden, nach ihren Fitnesswerten absteigend sortiert. Danach findet ein Crossover nach folgendem
Schema statt (es entstehen immer 2 unveränderte Eltern und 2 Kinder):
Das beste Individuum wird mit dem Zweitbesten gekreuzt.
Das zweitbeste Individuum wird mit dem Drittbesten gekreuzt.
Das drittbeste Individuum mit dem Viertbesten.
...
Das letzte Individuum wird in dieser Realisierung nicht mit dem 1. Individuum
gekreuzt, obwohl dies möglich wäre.
Bei 10 Eltern entstehen somit 9 Kinder = 19 Individuen im Genpool
 Methode 2: „Die Harems-Methode“
Hierbei werden die Individuen ebenfalls wie zuvor sortiert. Das Crossover hat nun
aber folgendes Prinzip (es entstehen wieder 2 unveränderte Eltern und 2 Kinder):
Das beste Individuum wird mit allen anderen Individuen gekreuzt.
Das zweitbeste Individuum mit allen, die eine schlechtere Fitness-Bewertung haben.
Das drittbeste Individuum mit allen, die eine schlechtere Fitness-Bewertung haben.
...
Hierbei werden mehr Nachkommen (höhere Lösungsvielfalt !) gebildet, als bei der
Methode 1. Wird jedoch die Anzahl der Nachkommen durch einen Parameter eingeschränkt, so kommt es zu einer starken Betonung der Gene des derzeit besten
Individuums, was zu einer verstärkten Tendenz zu suboptimalen, lokalen Lösungsminima führen kann.
Bei der Methode 2 entstehen beim Crossover der Eltern die folgende Anzahl an Kindern:
Seite 54
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
IndividuenZahl 1
 (2 * u)
2*
2 * IndividuenZahl 1
u 1
Beispiele der Kinderanzahl bei 100 prozentigem Crossover:
Anzahl der Individuen Anzahl der Kinder bei Anzahl der Kinder bei
(= Elternzahl bei
Methode 1
Methode 2
100 % Crossover)
10
9
159
12
11
239
20
19
719
32
31
1919
40
39
3039
56
55
6042
Eine Verkleinerung des Crossover-Anteils führt bei der Methode 2 in oft wiederholten Experimenten zu einer stärkeren Betonung der Gene der bis zu diesem Zeitpunkt besten Lösungen,
womit die Gefahr, als Lösung nur ein lokales Minimum zu erhalten, ansteigt.
Z e it in S e k u n d e n b is z u r
L ö su n g
Der Entwicklung der Kinderzahl entsprechend, entwickelt sich der Verlauf der bis zur Lösung benötigten CPU-Zeiten über der Anzahl der für die Optimierung benutzten Individuen,
wie folgt (gemittelt aus 10 verschiedenen Anfangszuständen, die sowohl für die Methode 1 als
auch für die Methode 2 jeweils gleich waren):
Mittelwert der CPU-Zeiten
50
Methode 2
40
30
20
Methode 1
10
0
20
24
28
32
36
40
44
Anzahl der Individuen
Seite 55
48
52
56
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
Z e it in S e k u n d e n b is z u r
L ö su n g
Da die Berechnung einer Generation bei der Methode 2 länger dauerte als bei der Methode 1,
waren die Zeiten, nach denen die Lösung zur Verfügung stand, bei der Methode 2 sehr breit
gestreut. Dies führt zu einer großen Standard-Abweichung bei der Bildung der mittleren Zeitdauer bis zur Lösung (wird eine zusätzliche Generation bis zum Erreichen der Lösung benötigt, so fällt dies bei der Methode 2 mit einer hohen Individuenzahl und damit sehr vielen
Nachkommen stärker ins Gewicht):
Standard Abweichung der CPU-Zeit
12
10
Methode 2
8
6
4
Methode 1
2
0
20
24
28
32
36
40
44
48
52
56
Anzahl der Individuen
Für die Methode 2 spricht, daß die Generationen-Zahl bis zur Lösung im ganzen getesteten
Bereich der Individuen-Anzahl beinahe konstant blieb, während bei der Methode 1 die Generationen-Zahl bis zum Erreichen der Lösung stärker schwankte.
Allerdings war bei der Methode 1 eine leichte Abnahme der bis zur Lösung benötigten Generationenzahl zu verzeichnen.
G e n e ra tio n e n z a h l b is
z u r L ö su n g
Erklärung: Da bei der Methode 1 nur wenige Nachkommen einer Generation gebildet werden, ist dieser Effekt leicht mit der Zunahme der Lösungsvielfalt beim Erhöhen der Individuen-Zahl zu erklären (bei der Methode 2 entstehen sowieso schon sehr viele Nachkommen):
Entwicklung der Generationenzahl
10
Methode 1
8
6
4
Methode 2
2
0
20
24
28
32
36
40
44
Individuen
Seite 56
48
52
56
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
4.1.3 Die Bedieneroberfläche von GA_BIN.M
Nummer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Beschreibung
Plot der Anzahl der fehlerhaften Bits über der Generationenzahl
Schieberegler für die Vorgabe des zu tolerierenden Restfehlers
Schieberegler für die Abbruchbedingung „letzte zu simulierende Generation“
Schieberegler für die Anzahl der simulierten Individuen
Pop-Up für die Auswahl der gewünschten Cross-Over-Methode
Pop-Up für die Vorgabe des Ziel-Bitmusters
CPU-Zeit für bisherige Berechnungen ( hier: AMD DX4-100 CPU / WfW 3.11 )
Anzahl der bisher aufgetretenen Mutationen
Schieberegler für die Mutationswahrscheinlichkeit
Schieberegler für die Cross-Over-Wahrscheinlichkeit, wobei 100 % Cross Over
eine vollständige Beteiligung der Eltern an der Bildung der Nachkommen bedeutet
Step-Button: Eine Generation wird simuliert, dann wird gewartet
Go-Button: Simulation starten
Stop-Button: Simulation anhalten
Restart-Button: Zurück auf den Anfangszustand (Zufallsgenerator wird ebenfalls
wie zu Beginn des letzten Startens eingestellt)
New-Button: Neustart des Programms
Done-Button: Beenden der Simulation
Statusmeldungs-Bereich
Info-Button: Öffnet ein Fenster mit Erläuterungen zum Programm GA_BIN.M
Seite 57
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
19
Show-Button: Anzeigen der Bitwerte der aktuellen Eltern- und Kinder-Population
Seite 58
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
Eine von GA_BIN.M generierte Startpopulation mit 10 Individuen kann folgendermaßen aussehen:
„Startgeneration“
Individuum 1
Individuum 2
Individuum 3
Individuum 4
Individuum 5
Individuum 6
Individuum 7
Individuum 8
Individuum 9
Individuum 10
27
1
1
1
1
0
1
1
1
1
1
26
0
0
0
1
0
1
1
1
1
0
25
1
1
0
0
1
0
0
1
1
0
24
0
1
0
0
0
0
0
1
0
1
23
1
1
1
1
0
0
1
1
0
0
22
0
1
0
0
1
0
1
0
0
0
21
1
0
1
1
0
1
1
0
0
0
20
0
0
1
1
1
1
0
1
0
1
Die einzelnen Bitwerte wurden durch den Zufallszahlen-Generator von MATLAB generiert.
Sollte zufällig schon die gewünschte Zielfunktion mit erzeugt werden, so wird diese nicht
aussortiert.
Nassi-Shneiderman-Diagramm zur Bitwerte-Erzeugung in GA_BIN.M:
p_eltern mit folgendem Befehl initialisieren:
p_eltern = randn(Individuen,8)
for i = 1:Individuen
for j = 1:8
Wert an der Stelle p_eltern (i,j) >=0
yes
p_eltern(i,j)=1
MatrixExists = true
no
p_eltern(i,j)=0
Der MATLAB-Befehl „randn“ erzeugt eine Matrix der Größe <Individuen * 8>. Die Zufallszahlen sind gleichverteilt und besitzen den Mittelwert Null (es entstehen positive und negative
Zahlen). Die nachfolgenden verschachtelten Schleifen i und j „digitalisieren“ die Zahlenwerte
in der generierten Matrix. Dazu werden alle Zahlenwerte kleiner Null zu „0“ und die Zahlenwerte größer oder gleich Null zu „1“ gewandelt.
Als MATLAB-Realisierung:
%-------------------- Action = RandomMatrix
if strcmp(Action,'RandomMatrix');
p_eltern = randn(Individuen,8);
for i = 1:Individuen,
for j = 1:8,
if(p_eltern(i,j)) >=0 p_eltern(i,j)=1;
else
p_eltern(i,j)=0;
end % if
end % for j
end % for i
MatrixExists = true;
end % Action=RandomMatrix
Eine schneller Lösung wäre natürlich denkbar, da dieser Vorgang aber nur einmal bei der ersten Generation ausgeführt wird, wurde diese erste Lösung beibehalten.
Seite 59
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
4.1.4 Weitere Erfahrungen aus der Benutzung von GA_BIN.M
Bei kleinen Populationsgrößen (Anzahl aller Individuen) kann leicht der Fall auftreten, daß
die vorhandene Lösungsvielfalt auf einer Genposition (Locus) zu klein ist (es sind nicht alle
möglichen Ausgangswerte an einer bestimmten Bitposition in der Population vorhanden). Im
nachfolgenden Bild ist so ein Fall dargestellt (Crossover-Methode 1). Eine kleine Zahl an Individuen (hier immerhin 20) begünstigt meist das Auftreten so einer Situation.
Zu sehen ist, daß nach der 8. Generation keine Verbesserung des Restfehlers mehr eintritt. Die
Mutationsrate ist 0 %. Die folgende Matrix stellt die interne Speichermatrix des Problems
nach der 8. Generation dar:
„8.Generation“
Individuum 1
Individuum 2
Individuum 3
Individuum 4
Individuum 5
Individuum 6
Individuum 7
Individuum 8
Individuum 9
Individuum 10
...
27
0
0
0
0
0
0
0
0
0
0
26
1
1
1
1
1
1
1
1
1
1
25
1
1
1
1
1
1
1
1
1
1
24
0
0
0
0
0
0
0
0
0
0
23
0
0
0
0
0
0
0
0
0
0
22
0
0
0
0
0
0
0
0
0
0
21
0
0
0
0
0
0
0
0
0
0
20
0
0
0
0
0
0
0
0
0
0
Zu sehen sind die jeweils 8 Bit der ersten 10 Individuen. Alle anderen Individuen besitzen
ebenfalls dieses Bitmuster. Der erwünschte Inhalt der blau markierten Spalte (22) wäre eine
„1“. Da wegen des eingestellten Crossover-Faktors nur die 10 besten Individuen die nächsten
Generation bilden, ist hier nach beliebig häufigem Crossover keine Besserung zu erwarten (es
Seite 60
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
entsteht auf dem Locus 22 niemals die gewünschte „1“). Abhilfe kann die Einführung der Mutation bieten, hierbei wird aber das Konvergenzverhalten der Lösung während der ersten Generationen schlechter. Durch die kräftige Konvergenztendenz der GA am Anfang der Optimierung ist dieser Effekt jedoch vernachlässigbar im Vergleich zum Nutzen der Mutation für
die Optimierung. Die Fehlerkurve unter Zuhilfenahme der Mutation ist in der nächsten Abbildung dargestellt.
Die Abbildung beruht auf den gleichen Ausgangsdaten wie das Bild auf der Seite 60.
Dazu wurde die gleiche Ausgangssituation geschaffen und der RANDOM-Generator auf den
gleichen Anfangswert gesetzt.
„8.Generation“
Individuum 1
Individuum 2
Individuum 3
Individuum 4
Individuum 5
Individuum 6
Individuum 7
Individuum 8
Individuum 9
Individuum 10
...
27
0
0
0
0
0
0
0
0
0
0
26
1
1
1
1
1
1
1
1
1
1
25
1
1
1
1
1
1
1
1
1
1
24
0
0
0
0
0
0
0
0
0
0
23
0
0
0
0
0
0
0
0
0
0
22
0
0
0
1
0
0
0
0
0
0
21
0
0
0
0
0
0
0
0
0
0
20
0
0
0
0
0
0
0
0
0
0
Zu sehen ist, daß durch die Mutation nach der 8. Generation die Lösungsvielfalt der MatrixSpalte des Bitwertes 22 erhöht wurde (Individuum 4) und somit der Fehler der Lösungsmatrix
zu „Null“ werden kann.
Seite 61
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
Eine Erhöhung des Crossover-Faktors von 50 % auf 100 % kann helfen, die Lösungsvielfalt in
den Genmustern auf einem hohen Niveau zu halten, stellt aber nicht sicher, daß es nicht zu
Situationen wie auf Seite 60 dargestellt kommen kann.
Seite 62
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
Auch bei der Crossover-Methode 2 kann es zu lockierungen im Evolutions-Zyklus kommen.
Wegen der größeren Anzahl von Nachkommen die durch diese Methode gebildet werden, ist
dies aber weniger wahrscheinlich als bei der Methode 1. Erkauft wird dieser Vorteil mit einer
verlängerten Rechenzeit. Wie zu sehen ist, bietet aber auch die Methode 2 keine Sicherheit
gegen das Auftreten von unerwünschten lokalen Minima:
Abhilfe kann auch hier durch eine Erhöhung des Crossover-Anteils ...
oder durch die Einführung der Mutation ...
Seite 63
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
7
geschaffen werden.
Auch in diesem Fall stellt die Mutation, in Maßen benutzt, kein Problem für das Konvergenzverhalten des GA dar.
Seite 64
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
4.2 Bedingung für den Einsatz von genetischen Algorithmen
Eine Erkenntnis bei der Erstellung dieser Arbeit betrifft die Bedingungen, unter denen sich
Probleme für eine Lösung mittels genetischer Algorithmen eignen. Als kleiner Vorgriff soll
dies hier nicht unerwähnt bleiben:
Ein GA-Einsatz ist nur dann sinnvoll möglich, wenn sich das Problem in voneinander unabhängigen Parametern darstellen läßt.
Begründung:
Sind die Parameter der Problemcodierung nicht voneinander unabhängig, so muß sich dem
Crossover-Vorgang ein weiterer Arbeitsgang anschließen, der ungültige Datensätze (Parameter-Kombinationen) in geeigneter Art und Weise in gültige Datensätze überführt.
Dieses Vorgehen entspricht aber einer komplizierten, problemorientierten Mutation; ein „ordentliches“ Crossover liegt in diesem Falle nicht mehr vor (die Mutation bei den GAs beschränkt sich im Allgemeinen auf die Invertierung einzelner Bitinformationen in den Genen
des Individuums, aufwendigere Korrekturalgorithmen würden der Mutation ein stärkeres Gewicht geben: In der GA ist die Mutation aber nur ein Hintergrundoperator mit geringem Einfluß auf das Konvergenzverhalten beim Weg zur Lösung).
Beispiel ist hier der Versuch einer GA-Realisierung des Travelling Salesman:
Mit dem Wissen, daß sich in einem Chromosom bei den GA auch die Codierung von mehr als
nur einer Zahl verbergen kann, ist der Versuch einer GA-Realisierung des Travelling Salesman Problems denkbar.
Die Index-Nummern der Städte dürfen jedoch nur einmal im Gen vertreten sein; nach der
Crossover-Operation wäre dies nicht sichergestellt: Ein anschließender Algorithmus müßte
dieses nach dem Crossover entstandene Problem lösen.
Es sind aber Problemcodierungen denkbar, die nicht den Index der Städte aus den Genen entnehmen, sondern z.B. nur die Richtung vorgeben, in der die nächste noch nicht besuchte Stadt
zu suchen ist. Hierbei wären die Geninhalte von ihrem direkten Bezug untereinander befreit
und eine genetische Realisierung wäre somit denkbar.
Seite 65
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
4.3 Weiterentwicklungen der genetischen Algorithmen
(Quelle: Universität of Illinois [15]{13})
Um bei immer komplexeren zu analysierenden Problemstellungen das Auftreten von lokalen
Optima zu verhindern, muß die Anzahl der simulierten Individuen bei immer komplexeren
Problemstellungen stark steigen.
Damit geht eine starke Steigerung des Rechenaufwands einher (und Rechenzeit kostet Geld).
Um die Rechenzeit zu verkürzen, wurde das Prinzip der Parallelen GA (PGA) ersonnen (es
können mit dem gleichen Aufwand an Rechenzeit auf parallelen Rechner mehr Individuen
simuliert werden, als bei der traditionellen GA möglich ist).
Goldberg hat 1991 (Quelle: [15]) als Anhaltspunkt für den Konvergenz-Aufwand der traditionellen GA folgendes Groß-O-Kalkül zur Abschätzung des Aufwands eingeführt:
Der Aufwand bis zum Erreichen der Konvergenz ist ungefähr von der Größenordnung
O(n log n)
wobei n der von der traditionellen GA simulierten Anzahl der Individuen entspricht.
Ausgehend von der Erkenntnis, daß die Evolution ein stark paralleler Prozeß ist, wurden folgende Wege zur Parallelisierung der GA angewandt:
 Parallelisierung der Crossover-Funktionen und der Mutationen innerhalb einer Generation
(globale Parallelisierung der GA). Das Crossover der Gene zweier Individuen findet mit
verschiedenen Individuenkombinationen innerhalb einer Generation bei der Erzeugung von
Kandidaten für die nächste Generation mehrfach statt. Damit kann das Crossover der Individuen-Paare auf mehreren Prozessoren parallel stattfinden. Genau gleich verhält es sich
mit dem Vorgang der Bitinvertierung bei der Mutation von Genen verschiedener Individuen.
 Aufteilen der großen Populationen in mehrere kleinere Sub-Populationen, die wie Staaten
in der realen Welt im Rechner koexistieren („coarse grained“ GA). Gleichzeitig wurde
zusätzlich zur Mutation und zum Crossover ein Emigrations-Operator („migration operator") neu eingeführt, der Individuen den Wechsel zwischen den Sub-Populationen erlaubt.
Die Subpopulationen können dann ebenfalls auf verschiedenen Prozessoren simuliert werden. Es ist hierbei jedoch immer darauf zu achten, daß ein zeitlicher Zusammenhang zwischen den Populationen bestehen bleibt (Stichwort: Synchronisation)
Als Ergebnis ist laut [15] mit einem Groß-O-Kalkül von
O( n )
zu rechnen.
Seite 66
Kapitel 4: Ein genetischer Algorithmus als MATLAB-Lösung
Es haben sich mehrere Realisierungen der coarse grained PGA als günstige Lösungsansätze
herauskristallisiert:
1. „Das Insel Modell“ (island model)
Die Individuen einer Sub-Population dieses Modells können zu einer beliebigen SubPopulation innerhalb des Modells wechseln (und somit ihre Gene in diese Population einbringen).
2. „Das Steinwurf Modell“ (stepping stone model)
Die Individuen in diesem Modell dürfen nur in angrenzende Sub-Populationen wechseln.
3. „Das feinkörnige Modell“ (fine grained model)
Bei diesem Modell wird die Population in sehr kleine Sub-Populationen aufgeteilt. Ziel ist
es, für jeden zu bestimmenden Parameter eines zu optimierenden Problems mindestens ein
Individuum bereitzuhalten. Dieses Modell stellt hohe Anforderungen an die Parallelität
der simulierenden Hardware.
Die Parallelisierung der GA ist nicht immer eine gute Idee:
Die Rechenzeit, die für die Kommunikation der einzelnen SubPopulationen aufgewendet wird, kann leicht die eigentliche Rechenzeit für
die relativ einfach gestalteten genetischen Algorithmen übersteigen.
Seite 67
Kapitel 5: Kurze Einführung in die MATLAB Fuzzy-Toolbox
Kapitel 5: Kurze Einführung in die MATLAB Fuzzy-Toolbox
Die Fuzzy-Toolbox läßt die Erstellung von Fuzzy-Systemen auf zwei Wegen zu:
1. Kommandozeilen-Aufrufe bei Benutzung von diversen Funktionen
2. Aufruf des graphischen GUI-Tools „Fuzzy“
Die Kommandozeilen-Aufrufe können dem Fuzzy-Toolbox-Handbuch entnommen werden;
zu den GUI-Tools soll es hier eine kurze Einführung geben.
Der Aufruf der GUI-BOX „Fuzzy“ bringt folgendes Fenster auf den Bildschirm (hier schon
mit einigen Parameter eines Fuzzy-Systems mit 2 Eingängen und einem Ausgangszweig):
Die über den Variablen „WasserTemp“, „WasserDruck“ und „ReglerStellung“ dargestellten
Zuordnungs-Kurven (Membership-Function = MF) sind nur Sinnbilder für die tatsächlich
definierten MFs. Durch Doppelklicken auf die Grafiken der Variablen gelangt der Benutzer zu
weiteren Fenstern, die eine genauere Spezifikation der Variablen ermöglichen.
Seite 68
Kapitel 5: Kurze Einführung in die MATLAB Fuzzy-Toolbox
5.1 Bedeutung der Verknüpfungsmethoden OR, IMP und AGG
5.1.1 Die Or-Methode
Die Or-Methode legt fest, wie aus den verschiedenen Ergebnissen der Fuzzifikation ein einheitlicher Wert für die nachfolgende Beschneidung der Ausgangs-MF gebildet wird. Zugelassen sind die Vorgaben „max“ und „probor“:
In diesem Beispiel findet der Or-Operator „max“ Anwendung:
Aus den von den Schnittpunkten der Eingangsvariablen „service“ und „food“ mit den Kurven
„poor“ und „rancid“ ausgehenden Linien wird nur diejenige weiter nach rechts abgebildet, die
den größeren Wert beschreibt. max( 0.3 ; 0.2 )  0.3
Der Or-Operator „probor“ bildet den resultierenden Ausgangswert zum Schneiden der Ausgangskurve nach der Rechenregel für ein „probabilistisches Oder“ nach der Formel:
probor(a,b) = a+b - a*b
In diesem Fall also: 0.3+0.2-(0.3*0.2)  0.44
Seite 69
Kapitel 5: Kurze Einführung in die MATLAB Fuzzy-Toolbox
5.1.2 Die Implication-Methode
Für die Implication-Methode sind die Operatoren „min“ und „prod“ zugelassen, wobei „min“
den bei der Or-Methode im Bild zu sehenden Kurvenbeschneidungs-Effekt hat.
Bei „prod“ wird die Ausgangskurve gestaucht, bis ihre obere Kante unter die resultierende der
Or-Funktion paßt:
5.1.3 Die Aggregation-Methode
Für die Aggregation-Methode sind die drei Operatoren „max“, „probor“ und „sum“ zugelassen.
Im Bild an der rechten Seite werden die drei beschnittenen Ausgangskurven mit Hilfe der „max“-Methode zu einer resultierenden Ausgangskurve zusammengefaßt. Dazu wird der jeweils größte Y-Wert
der drei beschnittenen Kurven in die resultierende Ausgangskurve
übernommen.
Bei der „probor“-Methode berechnet sich die resultierende Ausgangskurve durch punktweise Bildung des „probabilistischen Oders“
aus den Y-Werte der beschnittenen MF-Kurven nach der Formel von
Seite 69 (erweitert auf drei Variablen). Diese Punkte werden in die
resultierende Ausgangskurve übernommen.
Bei der „sum“-Methode wird die resultierende Ausgangskurve durch
punktweise Addition der Y-Werte der drei beschnittenen MF-Kurven
gebildet.
Nun muß sich noch der Vorgang der Defuzzifikation anschließen, um
aus der resultierenden Ausgangskurve einen scharfen Zahlenwert zu
gewinnen.
Seite 70
Kapitel 5: Kurze Einführung in die MATLAB Fuzzy-Toolbox
5.2 Die Defuzzifikations-Methoden
Bei der Defuzzifikation wird anhand der Ausgangskurve des Systems eine Zahl als scharfer
Ausgangswert gebildet. Bei der auf Seite 68 abgebildeten Oberfläche sind für die Defuzzifikation der durch Überlagerung entstandenen Ausgangsfigur folgende Operatoren zugelassen:
„centroid“ Es wird zur Defuzzifikation der X-Achsenwert
des Schwerpunktes der Ausgangsfigur ermittelt.
Beispiel:
„bisektor“ Es wird zur Defuzzifikation der mittlere XAchsenwert der Ausgangsfigur ermittelt.
Beispiel:
„mom“
Es wird der mittlere X-Achsenwert des Maximums ermittelt.
Beispiel:
„som“
Es wird der X-Achsenwert des kleinsten Betrages
des Maximums ermittelt.
Beispiel:
„lom“
Es wird der X-Achsenwert des größten Betrages
des Maximus ermittelt.
Beispiel:
Seite 71
Kapitel 5: Kurze Einführung in die MATLAB Fuzzy-Toolbox
Um eine der Kurvensinnbilder von Seite 68 zu verändern wird durch Doppelklicken auf die
Grafik der Variablen „Reglerstellung“ wird z.B. folgende Oberfläche aktiviert:
Hier sind die tatsächlich definierten MFs zu sehen. Durch markieren einer Kurve mit der
Maus kann der zur Kurve gehörende Parametersatz im Teilfenster „Current Membership
Function“ dargestellt und editiert werden. Änderungen bewirken eine Aktualisierung des
„Membership Plots“.
Seite 72
Kapitel 5: Kurze Einführung in die MATLAB Fuzzy-Toolbox
Eine Bewertung der eingegebenen Parameter läßt der aus der Oberfläche des Fuzzy-GUITools erreichbare „Surface-Plot“ zu (über den Menü-Punkt „View"). Hier wird die Ausgangskennline des Fuzzy-Systems über den beiden Eingangsvariablen graphisch dargestellt. Durch
„markieren-und-ziehen" kann die Ansichtsposition des Oberflächenplots mit der Maus verändert werden.
Eine Bewertung der Eignung des vom Benutzers erstellten Fuzzy-Systems für ein bestimmtes
Problem ist nicht möglich. Hier müssen bisher - ohne Ausnutzung anderer Hilfsmittel - die
Erfahrungen des Anwenders mit der Benutzung von Fuzzy-Systemen zu einer möglichst
brauchbaren Definition führen.
Weitere Informationen können dem ausführlicheren Benutzerhandbuch der Matlab-FuzzyToolbox entnommen werden.
Seite 73
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Die eigentliche Aufgabe dieser Diplomarbeit besteht - wie zuvor schon erwähnt - in der Erstellung eines Algorithmus, der die Ideen der genetischen / evolutionären Programmierung mit
den unscharfen Algorithmen der Fuzzy-Logik verbindet (im Weiteren wird dieser Algorithmus und das zugehörige Programm nur noch mit „ES-Fuzzy“ für „evolutionären StrategienFuzzy“ abgekürzt). Es soll ein einfacher selbstoptimierender Regler realisiert werden.
Es sollen Erfahrungen mit der Kombination aus evolutionären Systemen und Fuzzy-Logik
gewonnen werden.
6.1 Das Reglungsproblem des Beispiel-Systems
Der zu realisierende selbstoptimierende ES_FUZZY-Regler soll in einem System mit zwei
Eingangsgrößen und einer Ausgangsgröße entwickelt werden. Dazu wurde folgendes Reglungs-Problem angenommen:
Aus einem Behälter kann eine Flüssigkeit (hier:
Wasser) durch ein Ventil am Boden des Behälters entnommen werden. Die Fläche der Öffnung sei vorgegeben. Der Füllstand des Behälters und die Temperatur der enthaltenen Flüssigkeit wird fremdbeeinflußt. Füllstand und
Temperatur sind die beiden Eingangsgrößen des
ES_FUZZY-Reglers; die Stellgröße für das
Auslaßventil ist von der Ausgangsgröße des
ES_FUZZY-Reglers geführt. Ziel ist es, dem
Behälter pro Zeiteinheit (in diesem Fall wird als
Zeiteinheit 1 Sekunde angesetzt) eine möglichst
konstante, vom Benutzer vorgegebene, Energiemenge zu entnehmen.
Das Fuzzy-System bedient das Auslaßventil so, daß sich durch eine optimale Steuerung des
Auslaßventils eine möglichst kleine Regelabweichung vom Vorgabewert ergibt.
Folgenden Sachverhalt gilt es auf einen Fuzzy-Regler zu übertragen:
1. Steigt der Flüssigkeits-Pegel und wird somit die Durchflußgeschwindigkeit am Auslaßventil größer, muß das Ventil mehr geschlossen werden (denn mit der größeren Flüssigkeitsmenge verläßt auch mehr Energie den Behälter).
2. Fällt der Wasserpegel, muß sich das Auslaßventil öffnen.
3. Steigt die Temperatur der Flüssigkeit, muß das Ventil mehr geschlossen werden.
4. Fällt die Temperatur, muß das Ventil am Ausgang sich wieder öffnen.
Seite 74
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Das zuvor beschriebene Regelungsproblem wird dem Fuzzy-System über umgangssprachlich
verständliche Regeln mitgeteilt.
Die Fuzzy-Eingabesprache bedient sich dabei logischer Verknüpfungen, um Zusammenhänge
zwischen Fuzzy-Kurven darstellen zu können.
Für einen Beispiel eines Datensatzes in der Fuzzy-Eingabesprache werden folgende Variablenbezeichner eingeführt:
Variable
Bedeutung
WasserTemp
WasserDruck
aktuelle Wassertemperatur im Gefäß
aktueller Wasserdruck im Gefäß,
wobei der Wasserdruck in einem direkten physikalischen Zusammenhang mit dem Füllstand des Wassers im Gefäß steht
Klassifizierungsvariable
Sie steht für den Ausdruck:
"Das Wasser im Gefäß ist heiß"
Sie erhält, wie alle weiteren Klassifizierungsvariablen, ihre Bedeutung
an anderer Stelle durch eine Fuzzy-Zuordnungskurve (MF)
Klassifizierungsvariable.
Sie steht für den Ausdruck:
"Das Wasser im Gefäß ist kalt"
Klassifizierungsvariable.
Sie steht für den Ausdruck:
"Der Druck im Gefäß ist groß"
Klassifizierungsvariable.
Sie steht für den Ausdruck:
"Der Druck im Gefäß ist klein"
WasserHeiss
WasserKalt
DruckGross
DruckKlein
Nun der Beispiel-Datensatz für das Fuzzy-System:
1. If (WasserTemp is WasserHeiss) or (WasserDruck is DruckGross) then (ReglerStellung is ReglerZu)
2. If (WasserTemp is WasserKalt) or (WasserDruck is DruckKlein) then (ReglerStellung is ReglerAuf)
Dem Fuzzy-Tool von MATLAB können diese Regeln nach einen Doppelklick mit der Maus
auf den im Bild auf Seite 68 dargestellten weißen Kasten mitgeteilt werden.
Die Variablen wie z.B. „WasserHeiss“ erhalten ihre Bedeutung durch die Zuordnung einer
Membership-Funktion (Zuordnungskurve) die wie folgt aufgebaut wird:
MF1=
'WasserHeiss':
'gauss2mf',



Variable des
Zugeordnete linguistische Kurvenform
Kurvenbezeichners Beschreibung
Seite 75
[10 20 40 20]

kurvenbeschreibende
Parameter
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Aus dem kleine Beispiel-Datensatz von der vorherigen Seite generiert die MATLAB-FuzzyToolbox, unter Berücksichtigung von zusätzlichen Parametern und Default-Werten, folgende
Datei (als Beispiel dient: „ES_F1.FIS"):
[System]
Name='es_f1.fis'
Type='mamdani'
NumInputs=2
NumOutputs=1
NumRules=2
AndMethod='min'
OrMethod='max'
ImpMethod='min'
AggMethod='max'
DefuzzMethod='centroid'
%
%
%
%
%
%
%
%
%
%
%
[Input1]
Name='WasserTemp'
Range=[1 127]
NumMFs=2
MF1='WasserHeiss':'gauss2mf',[10 20 40 20]
MF2='WasserKalt':'gauss2mf',[20 110 120 60]
%
%
%
%
%
%
[Input2]
Name='WasserDruck'
Range=[1 127]
NumMFs=2
MF1='DruckGross':'gauss2mf',[10 20 40 20]
MF2='DruckKlein':'gauss2mf',[20 110 120 60]
% Beschreibung des 2. Eingangs
%
%
%
%
%
[Output1]
Name='ReglerStellung'
Range=[1 127]
NumMFs=2
MF1='ReglerZu':'gauss2mf',[10 20 40 20]
MF2='ReglerAuf':'gauss2mf',[20 110 120 60]
% Beschreibung des Ausgangszweiges
%
%
%
%
%
[Rules]
1 1, 1 (1) : 2
2 2, 2 (1) : 2
%
%
%
%
Bezeichnung der Reglerbeschreibung
Regler hat 2 Eingänge
und 1 Ausgang
2 Regel beschreiben den
Beschreibung in Kapitel
Beschreibung in Kapitel
Beschreibung in Kapitel
Beschreibung in Kapitel
Beschreibung in Kapitel
Regler
5
5
5
5
5
Beschreibung des 1. Eingangs
Bezeichnung des 1. Eingangs
Zahlenbereich seiner Eingangsparamter
Zahl der zugeordneten Kurven
Die 1. Kurve ist eine Gauss-Kurve
Die 2. Kurve ebenfalls
Verknüpfungstabelle zwischen den
Kurven (wird von der Fuzzy-Toolbox
erzeugt und hat nur für diese eine
interne Bedeutung)
Der Ansatzpunkt für den Einsatz der Genetik sind nun die in grün dargestellten Kurvenformen
wie z.B. ‘gauss2mf’, die blau dargestellten Parameter in eckigen Klammern, die die Kurvenform näher beschreiben und die Kurvenverknüpfungsparameter wie ‘min’ und ‘centroid’, die
hier in Magenta hervorgehoben sind. Der selbstoptimierende ES_FUZZY-Regler soll die Kurvenformen und die Kurvenparameter so optimieren, daß die Regelabweichung minimal wird.
Es existieren noch zusätzlich die Dateien „ES_F2.FIS“ und „ES_F3.FIS", in denen das Problem mit der gleichen Anzahl von Eingängen und Ausgängen, aber mit jeweils 5 bzw. 25 statt
jeweils 2 Membership-Funktionen beschrieben wird. Dies sollte den ES_FUZZY-Regler zu
einer noch besseren Anpassung an das Reglungsproblem befähigen.
Es können auch benutzerdefinierte Datensätze verwendet werden, diese müssen sich nur an
der Problemgeometrie (2 Eingänge und 1 Ausgang) orientieren und vom Typ „Mamdani"
sein..
Seite 76
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.1.1 Die physikalischen Grundlagen für die Systemsimulation
Bei der Bewertung des Simulations-Ergebnisses muß die Menge der dem Gefäß entnommenen Energie berechnet werden. Dazu wurden folgende Überlegungen durchgeführt (Formeln
aus [19] entnommen):
Formel für die Ausflußgeschwindigkeit aus Gefäßen
v
2 * g * h *
mit
v: Ausflußgeschwindigkeit
h: Druckhöhe
µ: Ausflußzahl
Einheit
[v] = Meter / Sekunde
[h] = Meter
[µ] dimensionslos
Bemerkung
Von Form des Ausflusses abhängig,
wird hier mit 1 angenommen
Formel für den Durchfluß durch Röhren
V=A*v*t
mit
V: Volumenfluß
Einheit
[V] = Meter3
Bemerkung
Wobei 1 m3 = 1000 Liter
= 1000 Kg angenommen werden
Wird als Ventil mit maximaler Öffnungsfläche von 0.09 Meter2 angenommen
A: Querschnitt der Röhre
[A] = Meter2
v: Ausflußgeschwindigkeit
t: Zeitabschnitt
[v] = Meter / Sekunde
[t] = Sekunde
Hier wird eine Zeitdauer von 1 Sekunde angesetzt
Flüssigkeitskonstante
Es wird als Flüssigkeit „Wasser“ angenommen:
cWasser = 4.182 KJ / (Kg*K)
Vereinfachend wird diese nur in einem schmalen Temperaturbereich um 20 °C gültige Flüssigkeitskonstante als für den gesamten auszuregelnden Temperaturbereich gültig angenommen und die Volumenänderung der Flüssigkeit über dem Temperaturverlauf vernachlässigt.
Wärmeinhalt eines Körpers der mit Wasser gefüllt ist:
Q = cWasser * Masse * Temp
mit [Masse] = kg und [Temp] = °C
Zusammengefaßt ergibt sich folgende Formel für die Energiemenge Q pro Zeiteinheit:
Q  C wasser
*A
2 * g * h *Temp
mit [Q] = J = (Kg * m2) / s2
Die Berechnung der abgegebenen Energiemenge leistet die Funktion „Q_CALC.M“ unter
Kenntnis der vom Regler eingestellten Ventilöffnungsfläche A sowie der zugehörigen Parameter für die Füllhöhe im Gefäß und für die zugehörige Temperatur.
Berechnet wird also Q (A, h, Temp) .
Seite 77
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.1.2 Die ideale Ausgangskennlinie des Fuzzy-Reglers
Um eine Vorstellung des idealen Ausgangskennlinienfeldes zu haben, wurde dieses wie folgt
berechnet und graphisch aufbereitet:
Zum Wertebereich der beiden Eingangsvariablen
 "Temperatur" der Flüssigkeit im Gefäß und
 "Füllhöhe" der Flüssigkeit im Gefäß
wurden mit einer Schrittweite von „3", der bei diesen Eingangswerten wünschenswerte FuzzyAusgangswert berechnet.
Dazu wird die Formel
Q  C wasser
*A
2 * g * h *Temp
von Seite 77 nach A umgestellt und mit dem Wissen, daß der benötige Wert am Ausgang des
Fuzzy-Reglers mit der Fläche A über
A = (FuzzyAusgang * mO) / (mZ)
mit mO  maximale Öffnungsfläche des Ventils
und mZ  maximaler Ausgangswert des Fuzzy-Systems
ist, folgt dann für den optimalen Ausgabewert des Fuzzy-Reglers bei einer bestimmten Temperatur und einer bestimmten Füllhöhe im Gefäß und bei einem festgelegten Zielwert für die
Energieabgabe
FuzzyOut = ((mZ / mO) * Zielwert) / (cWasser * Temperatur * sqrt(2*g*h))
Dieser Wert wurde als z-Achsenwert gespeichert.
Das Ausgangsfeld von FuzzyOut über den beiden Parametern Temperatur und Füllhöhe wird
auf der folgenden Seite dargestellt.
Für die Stützstellen des FuzzyOut-Feldes wurden bei der Berechnung eine Schrittweite von
„3“ benutzt, d.h. die Temperatur und die Füllhöhe wurden für jede neue Rechnung um 3 °C
bzw. um 3 cm erhöht.
Seite 78
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Die minimale Regelabweichung ist erreicht, wenn die vom Fuzzy-Regler generierte Ausgangskennlinie dieser Grafik entspricht (der Maximalwert von 200 beim Fuzzy Output Parameter bedeutet, daß die mit 9 cm2 vorgegebene Öffnungsfläche am Gefäßboden vollständig
geöffnet wird):
Das ausführende MATLAB-Programm „OPTIMAL.M“ ist auf der beigelegten MATLABDiskette im Verzeichnis ES_FUZZY enthalten.
Die diesem Plot zugrunde liegenden Daten dienen später als „Lerndatensatz" für den Test des
in der MATLAB-Toolbox integrierten „Neuronalen Fuzzy Optimierer" ANFIS.
Wie zu sehen ist, handelt es sich bei dem Problem um einen nicht einfach zu behandelnden
Fall:
 Für mittlere und große Füllhöhen und Temperaturen ist der Verlauf sehr flach
 Bei großen Füllhöhen und Temperaturen sind steile Anstiege in der Funktionskurve vorhanden
 Durch die Vorgabe des möglichen Wertebereiches des Fuzzy-System-Ausgangszweiges bei
der Erstellung des Fuzzy-Systems, sind die Ausgangswerte des Fuzzy-Systems auf diesen
Bereich beschränkt. Mit einer Limitierung der maximalen Öffnungsfläche des Ventils auf
den Wert 9 cm2 (Vorgabe), kann das System die gewünschte Funktion bei sehr kleinen
Füllhöhen und kleinen Temperaturen nicht mehr ausregeln.
Seite 79
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.2 Die Problemcodierung des ES_FUZZY-Reglers
Die evolutionären Algorithmen arbeiten, wie am Beispiel des „Binären GA“ und des „Travelling Salesman“ schon gezeigt wurde, mit Zahlenstrings bzw. Zahlenvektoren, deren einzelne
Gene das Problem verschlüsselt darstellen. Entsprechend soll auch hier vorgegangen werden.
Dazu folgende Bemerkungen zur Vorbereitung der Überlegungen:
Der Befehl „readfis“ liest vom Massenspeicher eine Fuzzy-Beschreibung ein (ein Beispiel für
solch eine Datei findet sich im Kapitel 6.1 Das Reglungsproblem des Beispiel-Systems).
Daraus wird eine Matrix erstellt, in der alle Informationen zu dem Fuzzy-System abgelegt
werden. Auf diese Matrix kann mit den Befehlen „getfis“ und „setfis“ lesend bzw. schreibend
zugegriffen werden.
Die Struktur dieser Matrix ist somit für den Benutzer nicht von Interesse und kann bei späteren Versionen der Toolbox verändert werden, ohne daß der Benutzer dadurch eine Nachteil
hat (da die Funktionen „getfis“ und „setfis“ in diesem Fall auch von MATHWORKS angepaßt
würden).
Während der evolutionären Optimierung müssen die Eigenschaften dieser Matrizen in irgend
einer Form gespeichert werden. Auf eine Speicherung der gesamten Fuzzy-Matrix im Gen
eines Individuums wurde aus 2 Gründen verzichtet:
1. Der hohe Aufwand für die Speicherung der gesamten Fuzzy-Matrix und der damit verbundene Geschwindigkeitsverlust beim Umgang mit größeren Matrizen
2. Die Fuzzy-Matrix liegt als 2-dimensionales Gebilde vor. Damit wäre eine 3-dimensionale
Matrix zur Speicherung von mehreren Individuen (Fuzzy-Matrizen) benötigt worden. Dies
wird von MATLAB nicht unterstützt.
Für die Optimierung wurden folgende Parameter des Fuzzy-System als qualitätsbestimmend
definiert und zur Speicherung im Chromosom eines Individuum herausgesucht:
1. Die Anzahl der Fuzzy-MF-Kurven in jedem Eingangs- bzw. Ausgangs-Zweig
2. Die Form der jeweiligen MF-Funktion (Typ der MF-Funktion)
3. Die kurvenbeschreibenden Parameter des jeweiligen MF-Typs
4. Die Verknüpfungsmethoden von AND, OR, IMP und AGG
5. Der zur Defuzzifkation gewählte Operator („centroid“, „som“, ...)
Seite 80
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Damit ergibt sich folgende Problemcodierung für ein Chromosom des
ES_FUZZY-Reglers (eine graphische Darstellung des Chromosoms ist am rechten
Rand dieser Seite eingefügt):
Gen Nr.
1
2
3
4
5
6
7
8
9
10
..
A1
A2
A3
A4
B1
B2
B3
B4
...
Beschreibung:
Fitness des Individuums, „-1“ wenn die Fitness noch nicht ermittelt
wurde (diese Information wurde nur aus Gründen der Übersichtlichkeit des Programmcodes in das Gen eingefügt !)
Anzahl der Eingangs-Kurven (MF-Kurven)
Anzahl der Ausgangs-Kurven (MF-Kurven)
„And-Methode“ der Fuzzy-Verknüpfung („min“ oder „prod“)
„Or-Mehode“ der Fuzzy-Verknüpfung („max“ oder „probor“)
„Imp-Methode“ der Fuzzy-Verknüpfung („min“ oder „probor“)
„Agg-Methode“ der Fuzzy-Verknüpfung
(„max“, „probor“ oder „sum“)
Defuzzifizierungs-Methode -> Index auf eine Liste
Codierung, die den 1. MF-Kurventyp bestimmt
Codierung, die den 2. MF-Kurventyp bestimmt
Hier folgen weitere MF-Kurventyp-Beschreibungen
(Anzahl: Summe Gen 2, Gen 3)
1. kurvenbeschreibender Parameter der 1. MF
2. kurvenbeschreibender Parameter der 1. MF
3. kurvenbeschreibender Parameter der 1. MF
4. kurvenbeschreibender Parameter der 1. MF
1. kurvenbeschreibender Parameter der 2. MF
2. kurvenbeschreibender Parameter der 2. MF
3. kurvenbeschreibender Parameter der 2. MF
4. kurvenbeschreibender Parameter der 2. MF
Es können noch weitere MF-Beschreibungen folgen
(Anzahl der Beschreibungen: Summe von Gen 2 und Gen 3)
Dabei entspricht A einer Zahl des Wertes 8+[Gen(2)+Gen(3)]+1 und B = A+4.
Bei der Kodierung wurden für die Gene 4 bis 7 folgende mögliche Zustände definiert:
Bezeichner:
„min“ „prod“ „max“ „probor“
Index auf eine „1“
„2“
„3“
„4“
Liste:
„sum“
„5“
Alle Geninformationen werden in einem MATLAB-Zahlenvektor abgelegt.
Seite 81
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.3 Die Mutationen des ES_FUZZY
Es wurden 4 Mutations-Varianten realisiert:
1. Mutationen der Membership-Parameter
2. Mutationen der Membership-Funktion
3. Mutationen der Fuzzy-Verknüpfungs-Regeln
4. Mutationen der Defuzzifikations-Methode
Diese Mutationen sollen in den nächsten vier Unterkapiteln vorgestellt werden.
6.3.1 Die Membership-Parameter-Mutation von ES_FUZZY
Bei der Membership-Parameter-Mutation (MPM) werden einzelne Gene mit Hilfe des Zufallszahlen-Generators durch neue Geninformationen ersetzt. Dazu folgendes NS-Diagramm:
1. Mutation : Parameter mutieren
Anzahl der im Fuzzy-System vorhandenen MFs aus der Summe der Gene 2 und 3 ermitteln:
InOutBloecke = sum (p_eltern(1,2:3))
Anzahl der zu erfolgenden Mutationen berechnen:
ZahlDerMutationen = round (MutationsFaktor*Individuen)
Erzeugen von Zufallszahlen, die auf zu mutierende Individuen zeigen:
Individuen_wahl = round(rand(ZahlDerMutationen,1)*Individuen+0.5)
Erzeugen von Zufallszahlen, die auf ein Gen innerhalb eines Individuums zeigen:
Gen_wahl = ((round(rand(ZahlDerMutationen,1)* InOutBloecke+0.5)*4)-4)+InOutBloecke+9
Erzeugen von Zufallszahlen, die neue Geninformationen darstellen:
Neuer_wert = round((rand(ZahlDerMutationen,1)*MaximumRange) -0.5)/(2*InOutBloecke)
Die Elterngeneration um die Anzahl der zu erwartenden Kinder erweitern:
p_eltern = [p_eltern; zeros(ZahlDerMutationen, size(p_eltern,2))]
FOR n=1:ZahlDerMutationen
Kopie des Elters anlegen:
p_eltern(pointer,:) = p_eltern(Individuen_wahl(n),:)
Zufaellig eine MF fuer die Mutation auswaehlen:
welches_MF_Teil = round(rand*4+0.5)-1
Neues Gen einsetzen -> Mutation durchfuehren:
p_eltern(pointer,(Gen_wahl(n)+welches_MF_Teil)) = Neuer_wert(n)
Zur Verhinderung von ungueltigen Loesungen MF sortieren:
p_eltern(pointer,Gen_wahl(n):Gen_wahl(n)+3) =
sort_0(p_eltern(pointer,Gen_wahl(n):Gen_wahl(n)+3))
Merken, dass das Kind noch keinen berechneten Fitnesswert besitzt:
p_eltern(pointer,1) = KeinEintrag
pointer=pointer+1
Zaehler fuer die Anzahl der aufgetretenen Mutationen aktualisieren:
MutationsCntr=MutationsCntr+ZahlDerMutationen
Seite 82
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.3.2 Die Membership-Funktions-Mutation von ES_FUZZY
Bei der Membership-Funktions-Mutation (MFM) wird die Geninformation über die anzuwendende MF durch den Index einer anderen MF ersetzt. Die kurvenbeschreibenden Parameter
der MF werden mit Hilfe der MATLAB-Funktion „mf2mf“ angepaßt.
Da diese Anpassung nur sehr ungenau die Kurve der beiden Funktionen angleicht, ist somit
trotzdem ein Veränderungseffekt zu verzeichnen.
MF2MF arbeitet nach folgendem Schema: es wird versucht, bei der Ausgangs-MF-Kurve und
der Ziel-MF-Kurve die beiden Kurvenpunkte für einen Zuordnungswert von 0.5 in Deckung
zu bringen. Im folgenden Bild wird MF2MF auf die Transformation von „gaussmf“ nach
„trimf“ angewendet:
Zum programmtechnischen Ablauf der MFM folgendes NS-Diagramm:
2. Mutation : MF-Typ mutieren
Anzahl der zu erfolgenden Mutationen berechnen:
ZahlDerMutationen=round(MutationsFaktor_MF*Individuen)
Erzeugen der Zufallszahlen auf einen Rutsch:
- Individuen_wahl: Zeiger zur Auswahl des zu mutierenden Individuums
Individuen_wahl = round(rand(ZahlDerMutationen,1)*Individuen+0.5)
- MF_wahl : Welche Membership-Functions sollen mutiert werden ?
MF_wahl = round(rand(ZahlDerMutationen,1)*InOutBloecke+0.5)
- Neuer Typ : Nummer der neuen MF-Funktion
NeuerTyp = round(rand(ZahlDerMutationen,1)*size(MFStrings,1)+0.5)
Vergroessern der Eltern-Generation um die Anzahl der zu erwartenden Mutationen:
p_eltern=[p_eltern; zeros(ZahlDerMutationen, size(p_eltern,2))]
FOR n=1:ZahlDerMutationen
Kopie des Elters anlegen und dabei den Typ aendern:
p_eltern(pointer,:) = chg_mfp(p_eltern(Individuen_wahl(n),:),MF_wahl(n),NeuerTyp(n))
Merken, dass das Kind noch keinen berechneten Fitnesswert besitzt:
p_eltern(pointer,1) = KeinEintrag
pointer=pointer+1
Zaehler fuer die Anzahl der aufgetretenen Mutationen akutalisieren:
MutationsCntr=MutationsCntr+ZahlDerMutationen
Seite 83
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.3.3 Die Verknüpfungs-Mutation von ES_FUZZY
Zur Mutation Verknüpfungsfunktionen (VM) wird bei dem Verknüpfungen AND, OR und
IMP einfach zwischen den beiden jeweils zugelassenen Operatoren gewechselt:
AND
OR
IMP
prod 
probor 
prod 
min
max
min
Bei der Verknüpfung AGG wird mit Hilfe des Zufallsgenerators ein neuer Wert aus den möglichen Operatoren „max“, „probor“ und „sum“ herausgesucht und eingesetzt.
Dazu folgendes NS-Diagramm:
Seite 84
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
3. Mutation : die 4 Verknuepfungsfunktionen der MFs mutieren
Das sind die Methoden: AND OR IMP AGG
Anzahl der zu erfolgenden Mutationen berechnen:
ZahlDerMutationen=round(MinMaxFaktor*Individuen)
Erzeugen der Zufallszahlen auf einen Rutsch:
- Individuen_wahl: Zeiger zur Auswahl des zu mutierenden Individuums
Individuen_wahl = round(rand(ZahlDerMutationen,1)*Individuen+0.5)
- Ziel_wahl : Welche Verknuepfungsfunktionen mutieren ?
Ziel_wahl = round(rand(ZahlDerMutationen,1)*4+0.5)+3
Vergroessern der Eltern-Generation um die Anzahl der zu erwartenden Mutationen
p_eltern=[p_eltern; zeros(ZahlDerMutationen, size(p_eltern,2))]
Nun die Mutationen durchfuehren:
FOR n=1:ZahlDerMutationen
Kopie des Elters anlegen:
p_eltern(pointer,:) = p_eltern(Individuen_wahl(n),:)
Die Mutation von AND, OR und IMP erfolgt durch eine "Invertierung"
Zuerst muss aber festgestellt werden, welcher Genteil mutiert werden soll:
Actual_Function=p_eltern(pointer,Ziel_wahl(n))
Actual_Function of
AND-METHODE soll mutiert werden
p_eltern(pointer,4) == min
yes
p_eltern(pointer,4) = prod
p_eltern(pointer,4) = min
OR-METHODE soll mutiert werden
p_eltern(pointer,5) == max
yes
p_eltern(pointer,5) = probor
p_eltern(pointer,5) = max
IMP-METHODE soll mutiert werden
p_eltern(pointer,5) == min
yes
p_eltern(pointer,5) = prod
p_eltern(pointer,5) = min
AGG-METHODE
p_eltern(pointer,7) = round( rand * 3 + 0.5) + 2
wobei 3 <=> max 4 <=> probor 5 <=> sum ergibt
Merken, dass das Kind noch keinen berechneten Fitnesswert besitzt:
p_eltern(pointer,Fit_Eintrag) = KeinEintrag
pointer=pointer+1
Zaehler fuer die Anzahl der aufgetretenen Mutationen aktualisieren:
MutationsCntr=MutationsCntr+ZahlDerMutationen
Seite 85
no
no
no
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.3.4 Die Defuzzifikations-Mutation von ES_FUZZY
Bei der Defuzzifikations-Mutation (DM) wird mit Hilfe des Zufallszahlen-Generators im
Chromosom eines Individuums eine veränderte Defuzzifikationsmethode eingetragen.
Mögliche Defuzzifkationen sind die in Kapitel 5.2 Die Defuzzifikations-Methoden beschriebenen Methoden: „centroid“, „bisektor“, „mom“, „som“ oder „lom“.
Dazu folgendes Nassi-Shneiderman-Diagramm:
4. Mutation : Defuzzifikations-Methode mutieren
Anzahl der zu erfolgenden Mutationen berechnen:
ZahlDerMutationen=round(DefuzzFaktor*Individuen)
Erzeugen der Zufallszahlen auf einen Rutsch:
- Individuen_wahl : Auswahl des zu mutierenden Individuums:
Individuen_wahl = round(rand(ZahlDerMutationen,1)*Individuen+0.5)
- Defuzz_wahl : Welche Defuzzifikation soll zugewiesen werden ?
Defuzz_wahl = round(rand(ZahlDerMutationen,1)*size(DefuzzTyp,1)+0.5)
Vergroessern der Eltern-Generation um die Anzahl der zu erwartenden Mutationen
p_eltern = [p_eltern; zeros(ZahlDerMutationen, size(p_eltern,2))]
FOR n=1:ZahlDerMutationen
Kopie des Elters anlegen:
p_eltern(pointer,:) = p_eltern(Individuen_wahl(n),:)
Neue Defuzzifikations-Methode eintragen:
p_eltern(pointer,8) = Defuzz_wahl(n)
Merken, dass das Kind noch keinen berechneten Fitnesswert besitzt:
p_eltern(pointer,1) = KeinEintrag
pointer=pointer+1
Zaehler fuer die Anzahl der aufgetretenen Mutationen aktualisieren:
MutationsCntr=MutationsCntr+ZahlDerMutationen
Seite 86
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.4 Hilfs-Klassifizierung der Fuzzy-Membership-Funktionen
Die Membership-Funktionen wurden zur weiteren Überprüfung in 6 Klassen eingeteilt.
In der folgenden Liste der Klasseneinteilungen stehen die Variablen a,b,c und d für die aktuellen Zahlenwerte der MF-Funktionsbeschreibung.
Beispiel der Handhabung der Tabelle am Ausschnitt aus einem beliebigen Chromosom:
Gen-Nr (Locus): ... 9
gespeicherte Zahl ... 2
...
...
15
4
16
6
17
2
18
8
...
...
Aus der am Locus 9 gespeicherten Geninformation wird mit Hilfe der 3. Spalte der unten abgebildeten Hilfstabelle auf eine Kurve vom Typ „GAUSS2MF“ geschlossen. Mit Hilfe der
hier nicht abgebildeten Information aus dem Chromosom über die Anzahl der MF-Funktionen
in den Eingängen und Ausgängen könnte z.B. ermittelt werden, daß die kurvenbeschreibenden
Parameter in den Genen des Locus 15 bis Locus 18 gefunden werden können.
Der Chromosomen-Ausschnitt steht somit für die MF GAUSS2MF(4,6,2,8) und ist die vollständige Beschreibung der Form einer Fuzzy-MF des Typs GAUSS2MF mit den Parametern
a=4, b=6, c=2 und d=8.
Mit Hilfe der Information aus der Spalte 5 kann nun überprüft werden, ob die Parameter der
Kurve in einer gültigen Form vorliegen.
Klasse MF-Funktion
1
1
1
2
3
4
4
4
5
6
6
GAUSS2MF
PSIGMF
DSIGMF
GBELLMF
TRIMF
SIGMF
SMF
ZMF
GAUSSMF
PIMF
TRAPMF
Index-Nr.
der Funktion
im Gen
2
3
1
4
5
6
7
8
9
10
11
In der Beschreibung vorkommende Parameter
a b c d
a b c d
a b c d
a b c
a b c
a b
a b
a b
a b
a b c d
a b c d
Bedingungen für
einen gültigen
Parametersatz
b<d
b<d
b<d
a < b < c und b>0
a < b < c und b>0
a<b
a<b
a<b
a<b
a<b<c<d
a<b<c<d
Formel zur Bestimmung der
Kurvenmitte
(b + d) / 2
(b + d) / 2
(b + d) / 2
c
b
(a + b) / 2
(a + b) / 2
(a + b) / 2
b
(b + b) / 2
(b + b) / 2
Anhand dieser Einteilung wird bei der Mutation von Membership-Parameter das Auftreten von ungültigen Lösungen verhindert:
Fehler, die die zur Mutation der MF-Parameter verwendete MATLAB-Funktion „mf2mf" (die
Funktion transformiert die kurvenbeschreibenden Parameter bei einem Wechsel von einer
MF-Funktion zu einer anderen MF-Funktion, um eine ähnliche Kurvenform zu erhalten, siehe
auch Seite 83) bei ungünstigen Konstellationen der MF-Parameter macht, können mit dem
Wissen aus der obigen Tabelle soweit korrigiert werden, daß die Ergebnisse der Mutation
nicht zu einer Unterbrechung der Simulation führen.
Dazu werden die kurvenbeschreibenden Parameter nach einer Transformation mit Hilfe der
obigen Regeln vor einer Verwendung geprüft und gegebenenfalls in einen Zustand überführt,
Seite 87
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
der nicht zu einem Programmabbruch führt (meist werden die Parameter dann einfach aufsteigend sortiert).
Seite 88
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.5 Die Bedieneroberfläche des MATLAB-Programmes ES_FUZZY.M
Der Aufruf des MATLAB-Programmes „ES_FUZZY.M“ öffnet 4 Fenster. Ein Hauptfenster
mit einem Plot des Evolutionsfortschritts und mit Slidern, Buttons und Pop-Ups um die Simulation beeinflussen zu können.
6.5.1 Das Hauptfenster
Im Hauptfenster wird der Fortschritt der Optimierung des besten Individuums und der Fortschritt der mittleren Fitness der gesamten Population dargestellt. Des weiteren finden sich hier
Bedienelemente mit Schiebereglern, Pop-Ups und verschiedene Funktions-Buttons. Die roten
Zahlen dienen nur der nachfolgenden Erklärung der Objekte im Fenster.
Seite 89
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Beschreibung der Fensterobjekte:
Nummer
1
2
3
4
5
6
7
8
9
10
11
12
Beschreibung
Schieberegler für die Abbruchbedingung „letzte zu simulierende Generation“
Schieberegler für die Anzahl der simulierten Individuen
Schieberegler für die zulässige Abweichung des Ergebnisses vom Vorgabewert
Schieberegler für den Vorgabewert des Ergebnisses (Zielwert der Optimierung)
Schieberegler für den Anteil der MinMax-Mutationen an der Generierung von
Nachkommen (100 % bedeutet, daß die Anzahl der durch diese Mutation gebildeten Nachkommen der unter 2 eingestellten Anzahl an Individuen entspricht)
Schieberegler für den Anteil der Value-Mutationen an der Generierung von Nachkommen (Bedeutung der %-Zahl: siehe 5)
Schieberegler für den Anteil der Membership-Function-Mutationen an der Generierung von Nachkommen (Bedeutung der %-Zahl: siehe 5)
Schieberegler für den Anteil der Defuzzifikations-Mutation an der Generierung
von Nachkommen (Bedeutung der %-Zahl: siehe 5)
Pop-Up-Menü zur Auswahl einer auf dem Datenspeicher hinterlegten FuzzyBeschreibungsdatei mit der Dateierweiterung „.FIS“. Es sind 3 FIS Dateien vordefiniert:
„ES_F1.FIS“: Ein Fuzzy-System mit 6 MFs
„ES_F2.FIS“: Ein Fuzzy-System mit 15 MFs
„ES_F3.FIS“: Ein Fuzzy-System mit 75 MFs
Des weiteren ist die Angabe einer benutzerdefinierten Quelldatei möglich.
Pop-Up-Menü, um die Ergebnisdarstellung in den anderen 3 Fenstern beeinflussen
zu können. Mögliche Optionen sind:
„All“:
Die Individuen der Elterngeneration und die mutierten Individuen
der
Nachkommen werden angezeigt.
„Children“: Nur die mutierten Nachkommen einer Generation werden angezeigt.
„Best“:
Nur das beste Individuum einer Generation wird mit seinen
Parametern angezeigt.
Pop-Up-Menü, das das Verhalten bei erreichen einer Abbruchbedingung beeinflußt. Mögliche Optionen sind:
„Stop when done“:
Wird der in 4 eingestellte Fehler mit einer der in 3 eingestellten Abweichung erreicht, so beendet das Programm die Berechnung von weiteren Generationen. Das
gilt auch für das Überschreiten der in 1 eingestellten maximalen Generationenzahl.
„Stop never“: Das Programm beachtet keine Abbruchbedingungen.
Pop-Up-Menü, das die Behandlung der Daten aus Quellfile mit der Dateiendung
„.FIS“ bestimmt. Mögliche Optionen sind:
„Use Source: yes“:
Es wird vorausgesetzt, daß sich der Ersteller des Quellfiles schon Gedanken über
die Systemoptimierung gemacht hat  Der Datensatz aus dem Quellfile wird als
Elter 1 mit in die Simulation übernommen (und muß sich dort bewähren), die anderen Eltern werden zufällig erzeugt.
„Use Source: no“:
Aus dem Quellfile wird nur die Geometrie des Fuzzy-Systems übernommen und
ansonsten Eltern mit zufälligen Ausgangswerten für die erste Generation erzeugt.
Seite 90
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
13
14
15
16
17
18
19
20
21
22
23
Pop-Up-Menü, das bestimmt, ob eine besondere Form der Optimierung benutzt
werden soll. Mögliche Optionen sind:
„Use Verteil: yes“:
Die erstellte MATLAB-Funktion VERTEIL.M wird während der Optimierung
aufgerufen. VERTEIL.M sorgt dafür, daß die Mittelpunkte der Zuordnungskurven
innerhalb eines Eingangs- oder Ausgangszweiges des Fuzzy-System gleichmäßig
von links-oben nach rechts-unten verteilt werden. Dies kann bei einigen Optimierungsproblemen die Konvergenz beschleunigen, bei anderen Problemen das Finden einer optimalen Lösung aber verhindern.
„Use Verteil: no“:
VERTEIL.M wird während der Optimierung nicht benutzt.
Step-Button: Das Programm simuliert eine Generation und stoppt dann wieder.
Go-Button: Das Programm startet die fortlaufende Simulation von Generationen.
Stop-Button: Das Programm beendet nach der nächsten Generation die Simulation
von weiteren Generationen.
Info-Button: Das Programm öffnet ein weiteres Fenster mit interaktiven HTMLSeiten, die erklärende Zusatzinformationen enthalten.
Restart-Button: Das Programm wird auf den letzten Anfangszustand zurückgesetzt
(Zufallsgenerator wird ebenfalls wie zu Beginn des letzten Startens eingestellt).
New-Button: Neustart des Programms
Done-Button: Beenden des Programms ES_FUZZY.M und schließen aller Fenster.
Mit diesen drei Buttons kann der Startwert der Generationen-Achse des Graphen
beeinflußt werden.
Der „<-“-Button verschiebt den Startpunkt zu kleineren Werten hin.
Der „->“-Button verschiebt den Startpunkt zu größeren Generationen-Zahlen hin.
Der „1“-Button setzt den Startwert der Generationendarstellung auf Darstellung ab
der erste Generation.
Statusmeldungs-Bereich
Dieser Plot stellt die Entwicklung der Fitnesswerte des zu optimierenden Systems
über der Generationenzahl dar. Die grüne, obere Kurve stellt den Verlauf der mittleren Fitness aller Individuen dar, die blaue, untere Kurve stellt die Entwicklung
der Fitness des besten Individuums über der Generationenzahl dar (wegen des
besseren Kontrastes wurde die im Programm gelbe Kurve hier Blau dargestellt).
Seite 91
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.5.2 Das Ruleview-Fenster
Im Ruleview-Fenster werden die Membership-Funktionen des derzeit aktuellen FuzzyDatensatzes grafisch aufbereitet dargestellt. Die beiden die Eingangs-Membership-Funktionen
schneidenden scharfen Eingangswerte können mit der Maus nach links und rechts verschoben
werden, die Kurven des Fuzzy-Systems werden dabei gemäß der Fuzzyfizierungs-Regeln und
der Defuzzifizierung-Funktion aktualisiert
Die zur Darstellung aufgerufene MATLAB-Funktion „MY_RV.M“ ist eine leicht abgewandelte Version der Orginalfunktion „RULEVIEW.M“ aus der FUZZY-Toolbox.
Geändert wurden folgende Eigenschaften:
 Der Name der MF-Kurve wird links neben dem Plot angezeigt
 Die Zustände der Operatoren „AND“, „OR“, „AGG“ und die eingestellte Defuzzifizierung
werden in der untersten Fußzeile angezeigt
 Das Programm ist nun von anderen MATLAB-Funktionen „fernbedienbar“. Vor allem läßt
es sich von einer anderen Funktion aus mit „close“ beenden.
 MY_RV läßt sich nun an eine bestimmte Position auf dem Bildschirm bringen. Diese Änderung bringt aber den Nachteil mit sich, daß MY_RV im Gegensatz zum RULEVIEWER
nicht mehr gleichzeitig mehrfach aufrufbar ist (dies ist für die Anwendung innerhalb von
ES_FUZZY ohne Bedeutung).
Seite 92
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.5.3 Das Fenster der Fuzzy-Ausgangswerte
Im 3. Fenster findet sich eine Darstellung des Regelverhaltens des derzeit aktuellen FuzzyDatensatzes. Der angestrebte Optimalfall ist im Kapitel 6.1.2 Die ideale Ausgangskennlinie
des Fuzzy-Reglers als Bild dargestellt worden.
Mit den im Fenster vorhandenen Buttons kann der Blickwinkel auf die Figur verändert werden.
Seite 93
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.5.4 Das Fitness-Fenster
Im 4. Fenster wird die Regelabweichung des derzeit aktuellen Fuzzy-Reglers abgebildet.
Ziel wäre eine möglichst ebene Fläche um die Null-Ebene der „Relative Fitness“-Achse.
Mit den im Fenster vorhandenen Buttons kann der Blickwinkel auf die Figur verändert werden.
Seite 94
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.6 Die Fitness-Funktion des ES_FUZZY-Reglers
Das Konvergenzverhalten von genetischen und evolutionären Algorithmen hängt in hohem
Maße von der Stabilität der Fitnessbewertung ab. Die Fitnessfunktion sollte eine reelle Zahl
errechnen, die der Tauglichkeit des bewerteten Individuums äquivalent ist.
Schätzt die Fitnessfunktion manche Systemzustände bezüglich ihres Potentials für die Optimierungen innerhalb der nächsten Generationen falsch ein, so konvergiert das System nicht
oder nur ungenügend, da gute Lösungsansätze aussortiert wurden.
Zur Berechnung des Fitnesswertes wird bei diesem ES_FUZZY-System das Ausgangskennlinienfeld des physikalischen Systems herangezogen (siehe Bild auf Seite 94). Bei dieser ESRealisierung wurde als Ziel der Optimierung ein kleiner Fitnesswert (im Idealfall „0“) vorgegeben.
Die Berechnung des Fitnesswertes findet in der MATLAB-Datei „ES_F_FIT.M" statt.
Der Fitnesswert einer Individuums wird berechnet aus der
R2 * std(R) * abs( max(R)-min(R) )
mit
R
std
abs
max
min
Matrix der Regelabweichungen eines Individuums
Standard-Abweichung
Absolutwert (Betrag)
Maximalwert
Minimalwert
Als MATLAB-Code:
MIN = min(min(fit_field));
MAX = max(max(fit_field));
Fit_Eintrag = sum(sum ...
(fit_field.*fit_field)) ...
*(std(fit_field(:))) ...
* abs(MAX-MIN);
end % if sign(MIN ...
 Den kleinsten (auch negativsten)
Fehlerwert ermitteln
 Den größten Fehlerwert ermitteln
 Das Quadrat der Fehlerwerte mit der
Differenz zwischen Minimalwert und
Maximalwert multiplizieren
Die in der Variablen <Fit_Eintrag> stehende Zahl beschreibt die Fitness des aktuelle FuzzySystems nur relativ zu anderen ebenso bewerteten Systemen, sagt aber nichts über eine mittlere Regelabweichung in irgend einer physikalischen Einheit aus (auch wenn sich die Einheit „J
4
" aus der Rechnung ableiten ließe !).
Das ES_FUZZY-Optimierungs-System erreichte beim Test einen relativen Fitnesswert von
1.905e+07 (berechnet durch ES_F_FIT.M) nach Berechnung von 250 Generationen. Dies entspricht, bei einem mittleren Startwert von 2.01e+11 (Mittelwert aus 20 verschiedenen Ausgangssituationen), einer Verbesserung des Fuzzy-Systems von ungefähr 4 Zehnerpotenzen.
Das zum Vergleich herangezogene ANFIS-Tool von MATHWORKS erreichte nach 100 Epochen der Optimierung mit einem relativen Fehler von 1.75e+10 nur eine Verbesserung des
Seite 95
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Fitnesswertes um 2 Zehnerpotenzen (auf diesen Test wird im Kapitel über das ANFIS-Tool ab
Seite 100 noch genauer eingegangen).
Seite 96
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.7 Konvergenzverhalten des Programmes ES_FUZZY.M
Bei der Optimierung konvergiert das Fuzzy-System nicht so eindeutig mit einer abklingenden
e-Funktion, wie es zum Beispiel beim TSP der Fall war.
Die ersten 50 Generationen sind in dem folgenden Bild nicht dargestellt, da hier mit einem
Fehler in der Größenordnung 1011 gestartet wurde und bei einer vollständigen Darstellung der
gesamten Kurve nicht mehr viel zu sehen gewesen wäre.
Konvergenz der Optimierungskurve:
Das Ergebnis der Optimierung ist für eine Anwendung wahrscheinlich nicht gut genug (zum
Vergleich: siehe Bild im Kapitel 6.1.2 Die ideale Ausgangskennlinie des Fuzzy-Reglers).
Es ist jedoch möglich, daß bei der vorgegebenen Reglerstruktur keine besseren Ergebnisse
möglich sind oder einfach nicht lange genug auf ein besseres Ergebnis gewartet wurde.
Es ist, wie so oft bei KI-Systemen:
Ob die beste Antwort eines Systems auf ein Problem schon vorliegt, ist unbekannt.
Seite 97
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
6.8 Denkbare technische Realisierung
Der mögliche Einsatz eines sich selbst optimierenden Fuzzy-Systems mit Unterstützung durch
evolutionäre Strategien ist in folgendem Blockschaltbild dargestellt:
Zu sehen ist im oberen, linken Viertel des Bildes das physikalische System, das den eigentlichen Regelkreis darstellt (hier wird nur noch gesteuert !). Im rechten Drittel des Bildes sind
die Speicher für die Gene der Individuen der Gesamtpopulation abgebildet. Links unten findet
sich die Simulation des physikalischen Systems.
Das System bildet in der Mutations-Steuerung durch Mutation der einzelnen Individuen immer neue Fuzzy-Systeme, die sich bei der Simulation bewähren müssen. Der innerhalb einer
Generation im Sinne einer minimalen Regelabweichung „beste Parametersatz" (ein FuzzySystem) wird über seinen Fitness-Wert ausgewählt und dem Fuzzy-Regler des physikalischen
Systems übertragen. Dieser steuert nun das physikalische System.
Seite 98
Kapitel 6: Fuzzy Logik mit evolutionären Strategien
Bemerkenswert sind folgende Tatsachen:
 Die Sollwertvorgabe für die erwünschte Energieabgabe liegt nur am simulierten System
an..
 Es erfolgt keine Ermittlung der Fehlerabweichung durch Differenzbildung (Berechnung
von Regelabweichungen) im physikalischen System.
 Das physikalische System kennt keinen Zeitbegriff; d.h. es reagiert auf Eingangswerte am
Fuzzy-System ohne Rücksicht auf den letzten zuvor anliegenden Wert. Damit stellen auch
beliebig steile Sprünge der Eingangswerte des zu regelnden Systems kein Problem für das
Regelverhalten des Fuzzy-Systems dar.
 Das physikalische Fuzzy-System ermittelt seinen Regler-Input-Wert aus einem in Form
von graphischen Kurvenfunktionen gespeicherten „Look-Up-Table".
 Soll der lernende Fuzzy-Regler für ein anderes Reglungsproblem eingesetzt werden, ist nur
die Fitness-Bewertungs-Funktion der Simulation neu zu erstellen.
 Die Mutations-Funktionen müssen nur ein einziges Mal definiert werden und können dann
immer für einen Fuzzy-Regler angewandt werden, so lange sich dieser nicht grundlegend in
seinen Eigenschaften ändert (z.B. der Wechsel der Logik von einem „Mamdami"-System
zu einem „Sugeno"-System).
 Ob das Fuzzy-System schon sein optimales Reglungsverhalten erlangt hat, ist nicht sicher
feststellbar.
Seite 99
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
Als fertiges Tool für die Optimierung von Fuzzy-Regeln bietet MATLAB einen neuronalen
Fuzzy-Optimierungs-Algorithmus an (ANFIS = Adaptive Neuro Fuzzy Inference System).
Dabei benutzt ANFIS durch den Benutzer vorgegebene Datensätze mit Eingangs-/Ausgangsrelationen, um mit einem Backpropagation-Algorithmus einen lernenden Fuzzy-Regler zu
realisieren.
Dabei gelten von der MATLAB-Seite her folgende Einschränkungen:
 Es werden nur Fuzzy-Systeme des Sugeno-Typs erster Ordnung akzeptiert.
 Es sind nur Systeme mit einem einzigen Ausgang realisierbar.
 Es werden höchstens 4 Eingänge des Systems berücksichtigt.
 Alle Regeln haben das gleiche Gewicht.
 Es werden keine benutzerdefinierten Defuzzifikation-Funktionen akzeptiert.
 Die Funktionen „sigmf“, „smf“, and „zmf“ werden nicht unterstützt
 Ein Eingangs-/Ausgangszweig kann nur MF eines einzigen Typs enthalten
Diese Einschränkungen wurden getroffen, da der ANFIS-Teil der Toolbox nicht die üblichen
M-Files während der Optimierung benutzt, sondern eigene kompilierte C-Programme. Dies
soll den Optimierungsvorgang beschleunigen.
Eine Beispiel-Befehlsfolge aus der MATLAB-Hilfe um ein ANFIS-System zu generieren und
zu optimieren könnte folgendermaßen aussehen:
x = (0:0.2:10);
y = sin(2*x)./exp(x/5) + randn(size(x))/30;
TrainData = [x y];
NumMfs = 5;
MfType = 'gbellmf';
NumEpochs = 20;
StepSize = 0.1;
InputFismat = genfis1(TrainData, NumMfs, MfType);
OutputFismat = ...
anfis(TrainData, InputFismat, [NumEpochs nan StepSize]);
yy = evalfis(x, OutputFismat);
plot(x, y, 'o', x, yy, 'x', x, y, 'y', x, yy, 'm');
legend('Training Data', 'ANFIS Output');
Seite 100
 X- und Y-Werte für das
Training erzeugen und in
der Matrix <TrainData> ablegen
 Anzahl der benutzen Membership-Funktions und deren
Form festlegen
 Anzahl der Epochen für die
Backpropagation festlegen
 StepSize für die Backpropagation festlegen
 Aus den Vorgaben eine
Default-FIS-Matrix generieren
 ANFIS aufrufen (nan entspricht dem IEEE Symbol
„Not a Number" und dient
nur als Platzhalter)
 Mit der optimierten FISMatrix <OutputFismat> eine
Regler-Ausgangskennlinie
generieren
 Und diese darstellen ...
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
Wie zu erkennen ist, bestehen die Trainingsdaten aus jeweils einem Datensatz, der die Werte
der Eingangsparameter und den zugehörigen (erwünschten) Ausgangsparameter enthält.
Seite 101
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
7.1 Eine Anwendung des ANFIS-Tools
Um ein Vergleichsergebnis zu ES_FUZZY zu erhalten, wurde das Programm
„TEST_ANF.M“ erstellt. Der Quellcode ist ab Seite 175 im Anhang abgedruckt. Es folgt das
Nassi-Shneiderman-Diagramm des Programmes:
Konstanten definieren:
c_wasser = 4.182
g = 9.82
Oeffnung = 0.09
Trainingsdatensatz TRAINDATA berechnen (wie bei dem Programm OPTIMAL.M)
Vorbereitungen fuer den Einsatz von ANFIS:
- Es sollen 5 MF je Eingang bzw. Ausgang vorhanden sein:
NumMfs = 5
- die Kurvenform soll "gbellmf" sein:
MfType = 'gbellmf'
- es sollen 100 Epochen gerechnet werden:
NumEpochs = 100
- gestartet wird mit einer Stepsize von 0.1:
StepSize = 0.1
Die MATLAB-FUNKTION genfis1 generiert nun ein Fuzzy-System nach den Vorgaben:
InputFismat = genfis1(TrainData, NumMfs, MfType)
Dieses Fuzzy-System wird ANFIS zur Optimierung uebergeben:
[OutputFismat, error, stepsize]= anfis(TrainData, InputFismat, [NumEpochs nan StepSize])
Jetzt die Ergebnisse visualisieren:
figure; plot (error) ; title('Error vs EPOCHE')
figure; plot(stepsize) ; title('Stepsize vs EPOCHE')
aus den Fuzzy-Ausgangs-Parametern die Fitness-oberflaeche berechnen:
fit_field= q_calc(OutputFismat/1000,Temperatur,Fuellhoehe) - 100
Jetzt den FitnessWert berechnen:
MIN = min(min(fit_field))
MAX = max(max(fit_field))
Fit_Eintrag = sum(sum(fit_field.*fit_field))*(std(fit_field(:)))*abs(MAX-MIN)
ANFIS stellt zur Fuzzy-Ausgangs-System-Erzeugung zwei Methode bereit:
genfis1:
genfis2:
Benützt polymorphe (generische) Routinen zur FIS-Matrix-Erstellung. Dazu werden die Mittelpunkte der MF-Kurven über dem Zahlenbereich des Ausgangswertes gleichmäßig verteilt.
Nach Aussagen vom MATHWORKS-Support wird intern ein an Fuzzy-Gewichte
angepaßtes Perceptron-Netz verwendet.
Benützt die Methode der „Subcluster“-Bildung zur FIS-Matrix-Erstellung. Dazu
werden intern aus der Menge des Lerndatensatzes günstige Untermengen extrahiert und diese dann einzeln einer Optimierung unterzogen.
Nach Aussagen vom MATHWORKS-Support wird intern ein an Fuzzy-Gewichte
angepaßtes Adaline-Netz verwendet.
Seite 102
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
Auf das Problem der Ausflußregelung angewandt (File: „TEST_ANF.M", 45 min Rechenzeit
auf HP 735-100 bei 50 Epochen für die Fehlerminimierung durch Error-Backpropagation)
lieferte ANFIS folgende Ergebnisse:
Plot der Ausgangskennlinie durch den Ruleviewer (Ideale Kennlinie in Kapitel 6.1.2):
Zu Anfang der Optimierung verteilt ANFIS die vorgegebene Anzahl von MembershipFunctions gleichmäßig über den Zahlenbereich der Eingabegrößen. ANFIS variiert nur die
Breite der einzelnen Funktionskurven während der Optimierung:
Die Anzahl der von „genfis“ angelegten Fuzzy-Regeln berechnet sich dabei nach der Formel:
Anzahl_der_MF Anzahl_der_Reglereingänge ,
in Falle 5 MFs und 2 Eingängen also 5 2 = 25 Regeln.
Ausschnitt aus einer solchen Regeldatei:
1. if (input1 is in1mf1) and (input2 is in2mf1) then (output is out1mf1) (1 )
2. if (input1 is in1mf1) and (input2 is in2mf2) then (output is out1mf2) (1 )
3. if (input1 is in1mf1) and (input2 is in2mf3) then (output is out1mf3) (1 )
4. if (input1 is in1mf1) and (input2 is in2mf4) then (output is out1mf4) (1 )
5. if (input1 is in1mf1) and (input2 is in2mf5) then (output is out1mf5) (1 )
6. if (input1 is in1mf2) and (input2 is in2mf1) then (output is out1mf6) (1 )
Seite 103
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
7. if (input1 is in1mf2) and (input2 is in2mf2) then (output is out1mf7) (1 ) ...
Seite 104
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
Das Ergebnis der Optimierung läßt sich über die Informationen aus den MembershipFunktions leicht aus dem NN extrahieren (leider ist der „Ruleviewer" mit der Darstellung einer so großen Anzahl von MFs leicht überfordert, der Verlauf des „outputs“ als Funktion der
beiden Eingänge „input1“ und „input2“ läßt sich aber erahnen):
Mit einem von ES_F_FIT.M berechneten Fitnesswert von 1.75e+10 (relativer Fitnessindex)
liegt das Ergebnis der Optimierung jedoch nicht in einem für die Anwendung vertretbaren
Bereich.
Seite 105
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
ANFIS verändert die anfangs mit dem Wert 0.1 angegebene Variable <StepSize> während der
Optimierung. Dies wird im folgenden Schaubild dargestellt:
Die Entwicklung der Wurzel des Fehlerquadrats über der Zahl der Optimierungsepochen:
Das ANFIS-TOOL stellt eine leistungsfähige Erweiterung der Fuzzy-Toolbox dar. Während
der Lernphase ist der Benutzer jedoch nicht über die Fortschritte des Systems informiert. Nach
Seite 106
Kapitel 7: Das ANFIS-Tool der MATLAB-Fuzzy-Toolbox
der 40. ten Epoche oszilliert der Restfehler nur noch um den Wert 230 herum ( leider keine
Konvergenz des Fehlers gegen den Wert „Null“)
Seite 107
Kapitel 8: Ergebnisse dieser Arbeit
Kapitel 8: Ergebnisse dieser Arbeit
8.1 Neue Klassifizierung der genetischen Algorithmen
Wird das Crossover der GA auf voneinander abhängige Geninformationen angewandt, so
können ungültige Lösungen entstehen (Beispiel: Crossover auf 2 Chromosomen des Travelling Salesman Problems -> Nach dem Crossover kann der Index einer Stadt mehr als einmal
im Chromosom eines Kindes auftreten. Dies ist laut der Problemformulierung unzulässig.)
Damit wird beim Vorhandensein voneinander abhängiger Geninformationen ein nachfolgender Algorithmus benötigt, der aus ungültigen Ergebnissen auf geeignete Art und Weise gültige
Lösungen erzeugt.
Die Notwendigkeit einer Nachbearbeitung des entstandenen neuen Chromosoms bringt der
Crossover-Funktion die Qualität einer besonderen Form einer Mutation.
Diese Erkenntnis führt zu folgendem SATZ:
"Genetische Algorithmen sind Sonderfälle der evolutionären Strategien, wobei das Crossover
nur eine besondere Form einer Mutation darstellt. Es muß somit möglich sein, die Bildungsgesetze der evolutionären Strategien ( - Regeln) auf die GA zu übertragen."
Eine weitere Ableitung aus dieser Erkenntnis:
"Genetische Algorithmen sind nur anwendbar, wenn die Informationen, die durch die Gene
eines Individuums repräsentiert werden, voneinander unabhängig sind. Im anderen Fall kann
eine Problemlösung nur durch Anwendung der evolutionären Strategien mit zu dem Problem
fest zugeordneten Mutations-Funktionen erfolgen."
Damit muß das Bild auf Seite 6 nun wie folgt verändert werden:
KI Systeme
Evolutionäre
Algorithmen
Genetische
Programmierung
Neuronale
Netze
Evolutions- Strategien
Sonderfall: Genetische
Algorithmen
Seite 108
Fuzzy
Logik
EvolutionsProgrammierung
Kapitel 8: Ergebnisse dieser Arbeit
8.2 Bedeutung der Fitness-Funktionen für KI-Optimierungen
Für den Erfolg der Optimierungsbemühungen ist die fehlerfreie Formulierung der FitnessBewertungs-Funktion von überragender Bedeutung.
Die Entwicklungstätigkeit verlagert sich von der Problemlösung in Detailfragen hin zur Lösungsbewertung.
Dies stellt aber den eigentlichen Vorteil bei der Realisierung von KI-Optimierungs-Methoden
dar, da die Bewertung einer Lösung meist einfacher ist, als die Entwicklung einer speziellen
Problemlösung.
Problem:
Die Fitness-Bewertungs-Funktion muß auch aus den am Anfang der Simulation auftretenden
chaotischen Lösungen (Start mit zufälligen Werten !) die richtige Auswahl treffen, sonst konvergiert das System nicht oder nur sehr zögernd zu optimalen Lösungen.
8.3 Problematik der Abbruchkriterien
Es ist nur selten ersichtlich, ob die „optimale Lösung" schon gefunden wurde, oder ob noch
weitere, bessere Lösungen existieren.
Hier kommt der Begriff der „Satisfaktion des Benutzers“ ins Spiel: Der an einer Optimierung
interessierte Benutzer entscheidet, wann er mit dem erreichten Fortschritt zufrieden ist und
entnimmt dann dem System die aktuellen Parameter als Ergebnis der Optimierung.
Bei der Erstellung der Beispiel-Programme hat sich außerdem folgendes Abbruchkriterium
bewährt:
Erreicht der Mittelwert der Fitness-Bewertungen der gesamten Population den Fitnesswert des
derzeit besten Individuums, so ist auch in der Folge nur selten mit einer weiteren Verbesserung des Simulationsergebnisses zu rechnen.
Ausdrücklich wird an dieser Stelle aber darauf hingewiesen, daß es sich beim Simulationsergebnis zu diesem Zeitpunkt nicht um ein absolutes Optimum handeln muß. Es ist nur so, daß
die Population in dieser Struktur (Anzahl der Individuen, Mutationswahrscheinlichkeiten) zu
einem lokalen Optimum gelangt ist, das auch das globale Optimum sein kann („Ratlosigkeit
der Population").
Da KI-Optimierungen nicht den gesamten möglichen Lösungsraum untersuchen, sondern
durch Auswahl erfolgversprechende Regionen des Suchraumes untersuchen, konvergiert die
Simulation nicht immer zum globalen Maximum bzw. Minimum.
Seite 109
Kapitel 8: Ergebnisse dieser Arbeit
8.4 Wann sind KI-Methoden sinnvoll anwendbar ?
KI-Optimierungs-Methoden sollten nicht auf Probleme anwandt werden, für die eine deterministische Lösung existiert oder bei der durch bekannte Regeln und Erfahrungswerte (‘über den
Daumen peilen’) schon sehr gute Lösungen gefunden werden können.
Ein Blick auf die Lösungskurve eines typischen Konvergenzverhaltens begründet diese Aussage (Abbildung von Seite 50):
Beim Start der Simulation aus dem Chaos einer zufällig generierten Lösung heraus, ist eine
starke Konvergenz zu besseren Lösungen zu beobachten. Ist das System aber schon relativ
gut, so sind nur noch kleine Fortschritte zu verzeichnen
Der Rechenaufwand, der zur Optimierung eines System betrieben werden muß, ist noch erheblich zu hoch. Die obere Kurve stammt von einem Optimierungslauf des Travelling Salesman Problems und dieses benötigte immerhin noch 6 Stunden auf einem heute gebräuchlichen
INTEL 486 DX4-100 Prozessor System um die 1300 Generationen zu berechnen. Ein Verzicht auf eine graphische Darstellung von Zwischenergebnissen könnte hier zwar zu einer
Steigerung der Effizienz beitragen, ändert an der Größenordnung des Zeitaufwandes jedoch
nichts wesentliches.
Hier müßte der Schritt zu einer Realisierung in einer nichtinterpretierenden Sprache der vierten oder fünften Generation (z.B. C++ oder Smalltalk) zur Effizienzsteigerung getan werden.
Seite 110
Kapitel 8: Ergebnisse dieser Arbeit
8.5 Abschließende Bewertung
KI-Methoden erfordern im Allgemeinen einen enormen Rechenzeitbedarf für die Generierung
einer Problemlösung.
Die für diese Diplomarbeit gewählte Realisierung der Beispiel-Lösungen als MATLABProgramme stellt für die Praxis keinen möglichen Lösungsweg dar, da MATLAB als Interpreter nicht immer die Lösungen in einer annehmbaren Zeit zur Verfügung stellen kann. Bei seinem ANFIS-Tool tut MATHWORKS auch den konsequenten Weg weg von dem M-Files hin
zu MEX-Files geschrieben in der Sprache C.
Für ein „Rapid Prototyping" ist das „normale“ MATLAB aber, meiner Ansicht nach, das Tool
der Wahl (laut MATHWORKS ist seit dem 10.12.1995 ein Compiler für MATLAB verfügbar, dessen effizenzsteigernde Auswirkung aber nur für aufwendige Schleifenkonstruktionen
versprochen wird).
Die behandelten KI-Optimierungs-Methoden stellen einen interessanten neuen Lösungsansatz
dar und haben bei (noch) nicht mit mathematischen Methoden faßbaren Problemformulierungen auf jeden Fall ihre Existenzberechtigung.
Mit der Verfügbarkeit von großer Rechenleistung auf kleinem Raum in der näheren Zukunft
steht den KI-Optimierungen in der Systemüberwachung und Systemanpassung bestimmt ein
weites Anwendungsfeld offen.
Ich möchte an dieser Stelle noch auf eines hinweisen:
Es wurde absichtlich darauf verzichtet, Ingenieurwissen in Optimierungsvorgänge einzubringen, um den genetischen / evolutionären Systemen die Gelegenheit zu bieten, ganz ohne
„Fremdeinfluß" zu agieren. Natürlich gilt dies nicht für die Mutations-Operationen, die Fitness-Funktionen und die Auswahlvorgänge bei der Selektion der besten Individuen. Für eine
technische Anwendung ist - mit gezielter Anwendung von Ingenieurwissen - sicherlich noch
eine Verbesserung des Konvergenzverhaltens zu erwarten.
Seite 111
Kapitel 9: Der Zufallsgenerator von MATLAB
Kapitel 9: Der Zufallsgenerator von MATLAB
9.1 Überprüfung des MATLAB Zufallsgenerators
In den erstellten MATLAB-Programmen wird in großem Umfang vom integrierten PseudoZufallsgenerator Gebrauch gemacht. Um sicherzustellen, daß die erzielten Ergebnisse nicht
von einer Ungleichverteilung der generierten Zufallszahlen herrühren, wurde dieser Generator
überprüft. Dazu wurde folgende MATLAB-Funktion erstellt:
 Es werden eine vorgegebene Anzahl an Zufallszahlen zwischen 0 und 0.999... generiert
und diese 100 Klassen (durch Multiplikation mit der Anzahl der Klassen und Abschneiden
der Nachkommastellen) zugeordnet.
 Jede Klassenzuordnung erhöht einen Zähler der Klasse um „1“.
 Um zu einer Darstellung der Wahrscheinlichkeitsdichte zu gelangen, wird die Häufigkeit in
jeder Klasse nach der Generierung der Zufallszahlen durch die mittlere Zuordnungshäufigkeit (Anzahl der Messungen / Anzahl der Klassen) geteilt. Bei einer guten Gleichverteilung
sollte nun der Mittelwert aller Klassen bei „1“ liegen.
function h=randtest
%% Konstanten
KlassenZahl = 100;
Messungen
= 1000000;
%% Da MATLAB mit Matrix(0) nicht umgehen kann ...
KlassenZahl=KlassenZahl+1;
%% Erst einmal das Klassen-Feld anlegen
Klassenfeld=zeros(KlassenZahl,1);
%% Izt die Schleife
for i=1:Messungen
%% Da MATLAB mit Matrix(0) nicht umgehen kann
%% wird mit „+1" die Zufallszahl <zuf> korrigiert
zuf=floor(rand*KlassenZahl)+1;
%% Die der „Zufallszahl <zuf+1>" zugeordnete
%% „Klasse <zuf+1>" um 1 erhoehen
Klassenfeld(zuf)=Klassenfeld(zuf)+1;
end % for i
Div_Konst=Messungen/KlassenZahl;
Klassenfeld=Klassenfeld/Div_Konst;
%% Auswertung der Standard-Abweichung
Std=std(Klassenfeld);
%% Auswertung des Mittelwertes
Mittel=mean(Klassenfeld);
%% Auswertung des Minimums
Min=min(Klassenfeld);
%% Auswertung des Maximums
Max=max(Klassenfeld);
%% und graphisch darstellen...
my_fig=figure;
plot(Klassenfeld)
set(gca,'xlim',[1 KlassenZahl])
xlabel('-> Klassen');
ylabel('-> relative Haeufigkeit');
title(['Std: ',num2str(Std),' Mittel: ',num2str(Mittel), ...
' Min: ',num2str(Min),' Max: ',num2str(Max)]);
end % function
Seite 112
Kapitel 9: Der Zufallsgenerator von MATLAB
9.2 Der MATLAB Zufallsgenerator: Ergebnis und Bewertung
Die Funktion „RANDTEST.M“ liefert als Ergebnis folgende zusammenfassende Grafik:
Typische Wahrscheinlichkeitsdichte des MATLAB-Zufallsgenerator (1 000 000 Werte  220 )
Der MATLAB-Zufallsgenerator bildet die Zahlenfolge nach folgendem Gesetz:
y = ( 75 * y-1 ) mod ( 231 - 1)
(Quelle: Mathworks Inc.USA)
Der Mittelwert der relativen Häufigkeit über den Klassen wurde mit „1“ ermittelt und entspricht damit dem Erwartungswert für diese Häufigkeit.
Es wird bei der Ermittlung der Standard-Abweichung ein systematischer Fehler in der Größenordnung von 0.005 gemacht (bei angenommener Gleichverteilung der Zahlen innerhalb
einer Klasse und einer Klassenanzahl von 100 Klassen).
Aus technischen Gründen (Speicherplatzbedarf und Rechenzeit) konnte nicht der vollständige
Zyklus von 231 Zufallszahlen untersucht werden.
Abschließende Bewertung:
Die Daten lassen nicht auf eine Ungleichverteilung der Pseudo-Zufallszahlen schließen. Damit kann behauptet werden, daß die Simulationsergebnisse nicht durch eine Fehlfunktion des
Zufallsgenerators verfälscht wurden.
Seite 113
Kapitel 10: Gefahren bei der Anwendung von künstlicher Intelligenz
Kapitel 10: Gefahren bei der Anwendung von künstlicher Intelligenz
Die obige Abbildung mag als überspitzte Darstellung erscheinen, trifft aber meiner Ansicht
nach das Problem:
KI-Systeme operieren nur aufgrund zuvor eingegebener Informationen (z.B. vom Benutzer
erstellte Ableitungssysteme oder Datenbanken). Aus diesem begrenzten Fundus von Wissen
heraus beantworten die KI-Systeme Anfragen der Benutzer.
Ist dem Benutzer nicht immer bewußt, daß er sich mit Ergebnissen eines KI-Systems beschäftigt und unterläßt der Benutzer die kritische Hinterfragung von Rechner-Ergebnissen, so kann
die Anwendung und Bewertung von Ergebnissen eines KI-Systemen fatale Folgen haben.
Die Ersteller und Benutzer von KI-Systemen sind deshalb aufgefordert, Ergebnisse immer
auch auf ihre Plausibilität zu überwachen (vor allem bei nicht vom Menschen überwachten,
automatischen Prozeßvorgängen).
Seite 114
Kapitel 11: Liste der verwendeten Abkürzungen
Kapitel 11: Liste der verwendeten Abkürzungen
ANFIS
Adaptive Neuronal Fuzzy Inference System
DM
Defuzzifikations-Mutation
EA
Evolutionäre Algorithmen
EP
Evolutionäre Programmierung
ES
Evolutionäre Strategien
ES_FUZZY
FUZZY-System mit evolutionären Strategien
FIS
Fuzzy Interference System
FTP
File Transfer Protocol
GA
Genetische Algorithmen
GP
Genetische Programmierung
KI
Künstliche Intelligenz
MF
Membership Function - Kurve des MATLAB Fuzzy-Systems
MFM
Membership-Funktions-Mutation
MPM
Membership-Parameter-Mutation
NEF
Neuronales Fuzzy
NEFCLASS
NEuro Fuzzy CLASSification
NN
Neuronale Netze
PGA
Parallele Genetische Algorithmen
TSP
Travelling Salesman Problem
VM
Verknüpfungs-Mutation
WfW
Windows for Workgroups
Seite 115
Kapitel 12: Quellen
Kapitel 12: Quellen
12.1 Internet Adressen zum Thema
{1}
http://www.cs.tu-bs.de
TU Braunschweig
{2}
http://galaxy.einet.net:80/galaxy/Engineering-andTechnology/Computer-Technology/ArtificialIntelligence/Genetic-Algorithms.html
{3}
http://gal4.ge.uiuc.edu:80/illigal.home.html
University of
Illinoise
Genetic Algorithms
{4}
http://www.aic.nrl.navy.mil:80/galist/src/INDEX
US Narval Labs
Aritfical Intelligence
{5}
http://www.cs.washington.edu:80/research/jair/volume2/t White House
urney95a-html/title.html
Empirical Evaluation
{6}
http://www.wi.leidenuniv.nl:80/CS/LP/summary.html
- Theory of
Programming Languages
{7}
http://alife.santafe.edu:80/alife/topics/simulators/dret/
dret.html
University of
Santafe
Artificial-Life Simulators
and Their Applications
{8}
http://www.med.ufl.edu:80/medinfo/baseline/HN2.html
Medical Infobase
ACLS Algorithms
{9}
http://www.algorithm.com:80/squid/squid.html
Algorithm
{10}
http://www.cc.duth.gr:80/~mboudour/nonlin.html
Nonlinearity and
Complexity
{11}
http://ai.iit.nrc.ca:80/cscsi/cai/web.html
Canadian AI Magazine
{12}
http://www.boystown.org:80/hhirr/glossary.html
Genetic Terms
{13}
http://wwwhost.cc.utexas.edu/cc/staff/mccoy/gp/gp.html
Texas
Programm Archiv über
Genetische Algorithmen
{14}
http://cnls-www.lanl.gov/welcome.html
Los Alamos Lab’s
Non-Linear Studies
{15}
http://www.erg.abdn.ac.uk/projects/alife/html.dir
Aberdeen
Current Alife Digest
{16}
http://www.ai.mit.edu/pubs.html
MIT AI Home page Indices of the AI
publications of the MIT
{17}
http://ai.iit.narc.ca/ai_point.html
Pointers to AI Resources
{18}
http://www.krl.caltech.edu/avida
AVIDA Group
US California /
Pasadena
auto-adaptive genetic
systems
{19}
http://kal-el.ugr.es/geneura.html
Grenada, Spain
Artificial Worlds
{20}
http://www.mathworks.com
USA
Entwickler von
MATLAB
Seite 116
Neuronale Fuzzyregler
Genetic Algorithms
Kapitel 12: Quellen
Seite 117
Kapitel 12: Quellen
12.2 Verwendete Literatur
Einige dieser Bücher sind im Text nicht direkt zitiert worden, aus ihnen entnommenes Wissen
ist aber in diese Arbeit eingeflossen.
[1]
Duden Informatik
Dudenverlag
[2]
Evolutionsstrategie ‘73
Rechenberg, Ingo
F.Frommann Verlag
[3]
Evolutionäre Algorithmen
Nissen, Volker
DUV Deutscher UniversiätsVerlag
[4]
Genetische Algorithmen und
Evolutionsstrategien
Schöneburg, Eberhard
Heinzmann, Frank
Feddersen, Sven
Addision-Wesley
[5]
Genetic Algorithms
IEEE COMPUTER June 94
IEEE
[6]
Neuronal Networks +
IEEE January 1994
IEEE
[7]
Die Evolutionsstrategie ein universelles Optimierungswerkzeug
Herdy, Michael
Aufsatz: TU Berlin
[8]
Neuronale Fuzzy-Systeme
Kruse, Rudolf
Nauck, Detlef
Klawonn, Frank
Spektrum der Wissenschaft
Juni 1995
[9]
Wunder der Evolution
Blümecke,
Thomas
C’T Computermagazin
Heft 12, 1991
[10]
Niching Methodes In Genetic
Algorithms
Mahfoud, S.W.
University of Illinois - Genetic Algorithms Laboratory
Report 95001
[11]
Critical Deme Size For Serial And
Parallel Genetic Algorithms
Goldberg, D.E.
Kargupta, H.
Horn, J.
Cantu-Paz, E.
University of Illinois - Genetic Algorithms Laboratory Report 95002
[12]
Organizational Learning Within A Learning Classifier System
Wilcox, J.R.
University of Illinois - Genetic Algorithms Laboratory
Report 95003
[13]
Genetic Algorithms, Problem Difficulty,
And The Modality Of Fitness Landscapes
Horn, J.
University of Illinois - Genetic Algorithms Laboratory
Report 95004
[14]
Genetic Algorithms,Tournament Selection, And
The Effects Of Noise
Miller, B.
Goldberg, D.
University of Illinois - Genetic Algorithms Laboratory
Report 95006
[15]
A Summary Of Research On Parallel Genetic
Algorithms
[16]
Artificial Genetic Adaptation in Computer
Control Systems
Hollstien, R.B.
University of Michigan,
Disseration
[17]
NEFCLASS - A NEURO-FUZZY APPROACH
FOR THE CLASSIFICATION OF DATA
Detlef Nauck,
Rudolf Kruse
Technische Universität
von Braunschweig
[18]
Learning and Complexity in Genetic AutoAdaptive Systems
[19]
Taschenbuch der Physik
Horst Kuchling
Fachbuchverlag Leipzig
[20]
Skrpt „Bildverarbeitung und Neuronale Netze“
Eberhard Kienzle
FH-Esslingen
University of Illinois - Genetic Algorithms Laboratory Report 95007
Avida Group of the California Institude
of Technology / Pasadena
Seite 118
Kapitel 13: Die beigefügten Disketten
Kapitel 13: Die beigefügten Disketten
13.1 NEFCLASS - Diskette
NEFCLASS ist ein Testsystem für Neuronale Fuzzy Regler der TU Braunschweig und darf für
Forschung und Lehre frei verbreitet werden.
Auf der Diskette befindet sich die Versionen 1.5 im Verzeichnis NEFCLASS.1_5 und die
Version 2.0 dieses Programmes im Verzeichnis NEFCLASS.2_0, jeweils als selbstentpackendes Archiv.
Updates und weitere Informationen sind unter der Computerquelle {1} verfügbar.
13.2 MATLAB - Diskette
Die zweite beigelegte Diskette enthält die Source-Codes zu den für diese Diplomarbeit erstellten MATLAB-Funktionen in verschiedenen Verzeichnissen:
Verzeichnis GA_BIN:
Das MATLAB-Programm GA_BIN besteht aus dem Hauptprogramm und einer Hilfsfunktion.
 GA_BIN.M
 X_OVER.M
Hauptprogramm: Ein binärer genetischer Algorithmus
Die Crossover-Funktion zu GA_BIN.M
Verzeichnis ES_TSP:
Das MATLAB-Programm ES_TSP besteht aus einem Hauptprogramm und den Hilfsfunktionen „STR_DEL" und „STR_INS".
 ES_TSP.M
 STR_DEL.M
 STR_INS.M
Hauptprogramm: Travelling Salesman Problem als ESProgrammierung
Funktion zum Löschen von String-Teilen
Funktion zum Einfügen in Strings
Verzeichnis TOOLS:
 FIG_TEXT.M
 RANDTEST.M
 SORT_0.M
 TEST_ANF.M
Ein von MATHWORKS bereitgestelltes M-File zur vereinfachten
Textausgabe in Grafikfenstern
(nicht bei allen Installationen enthalten)
Testprogramm für den MATLAB Random - Generator
Sortiert Zahlenfolgen aufsteigend, wobei Nullen an das Ende der
Zahlenfolge geschrieben werden
Programm, das zum Testen des ANFIS-Tools der FUZZYToolbox verwendet wurde
Seite 119
Kapitel 13: Die beigefügten Disketten
Verzeichnis ES_FUZZY:
Das MATLAB-Programm ES_FUZZY besteht aus dem Hauptprogramm und den Hilfsfunktionen
 CHG_MFP.M
 ES_CNTRL.M






ES_F_FIT.M
ES_F1.FIS
ES_F2.FIS
ES_F3.FIS
ES_FUZZY.M
EVALMFP.M
 MY_RV.M
 OPTIMAL.M
 Q_CALC.M
 VERTEIL.M
Hilfsfunktionen für ES_FUZZY.M, die die Verwaltung der Slider,
Buttons und Popup-Menüs betreffen
Fitnessfunktion von ES_FUZZY.M
Definitionen für eine FIS-Matrix (3 Spalten 2 Zeilen)
Definitionen für eine FIS-Matrix (3 Spalten 5 Zeilen)
Definitionen für eine FIS-Matrix (3 Spalten 25 Zeilen)
Hauptprogramm: Evolutionäre Strategie zur Fuzzy-Optimierung
Hilfsfunktion für ES_FUZZY.M zur Dekodierung der Gene als
Fuzzy-Matrix
Modifizierte RULEVIEW.M für ES_FUZZY.M
Ausgabe der im besten Fall zu erwartenden Ausgangskennline des
Fuzzy-Reglers
Hilfsfunktion für ES_FUZZY.M
Sorgt für eine gleichmäßige Verteilung der Kurvenmittelpunkte
der MFs von einem Eingangszweig (für bessere Perfomance)
Seite 120
Kapitel 14: Programm-Texte
Kapitel 14: Programm-Texte
Nachfolgend sind die Programmtexte der erstellten MATLAB-Programme abgedruckt. Im
Kopf eines jeden Programmtextes finden sich Informationen über die abgedruckte Version
und deren letztes Aktualisierungsdatum. Die Eingabe- und Ausgabeparameter sind kurz erläutert.
Sollten diese Programme weiterbenutzt werden und dabei unlösbar erscheinende Probleme
auftreten, so kann über Internet jederzeit mit dem Diplomanden Kontakt aufgenommen werden.
Auf einer eingerichteten Internet-Homepage können aktualisierte Versionen der MATLABProgramme per FTP abgerufen werden:
Adresse der Homepage:
E-Mail-Adresse:
http://ourworld.compuserve.com/homepages/JEE_HOME
[email protected]
14.1 Das MATLAB-Programm GA_BIN.M
14.1.1 GA_BIN.M
Das Programm wurde geschrieben, um die Wirkung des Crossovers zu zeigen und die Bedeutung der Mutation für die genetischen Algorithmen zu verdeutlichen.
Die eigentliche Simulation / Optimierung findet im Programmteil mit der Action „Loop" statt.
function GA_BIN(Action)
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Funktion GA_BIN - Binaerer Genetischer Algorithmus
Version 2.0
(c) Jan-Erik Engels 1995
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 28.10.95
Beschreibung:
Es wird eine zufaellige Matrix mit <Individuen> Zeilen und 8 Spalten
mit den Werten "0" und "1" erzeugt. Die Fitness dieser Individuen
wird ueber die Anzahl der mit Vergleichs-Vektor <Ziel> nicht uebereinstimmenden Allelen berechnet. Von den einzelnen Zeilen werden die
Zeilen mit dem besten (kleinsten) Fitness-Wert fuer ein Cross-Over
ausgewaehlt. Es koennen, je nach Reglerstellung <Mutationsfaktor>,
Mutationen auftreten. Dabei werden zufaellige Alleln invertiert.
Abbruchbedingungen sind:
- maximale Anzahl an zu berechnenden Generationen erreicht <MaxGenerations>
- mindeste Anzahl an fehlerhaften Allelen <MaxFehler> unterschritten
- "Stop"-Button bedient <Endbedingung>=true
Moegliche Aufrufparameter <Action> (in alphabetischer Reihenfolge):
(User benutzt "GA_BIN" ohne Aufrufparamter !!!)
-
'Done'
'Go'
'Info'
'InfoMore'
'InfoDone'
'Loop_Methode1'
'Loop_Methode2'
:
:
:
:
:
:
:
Beendet GA_BIN.M
Starten der Generationsberechnung
Oeffnet ein Fenster mit zusaetzlichen Informationen
Aktiviert das naechste Informations-Fenster
Schliesst das Informations-Fenster
Schleife der Generationsberechnung
Schleife der Generationsberechnung
Seite 121
Kapitel 14: Programm-Texte
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
-
'New'
:
'RandomMatrix'
:
'Redraw'
:
'Restart'
:
'SetCrossAnteile':
'SetCrossFaktor' :
'SetFehler'
:
'SetMaxGen'
:
-
'SetMethode'
'SetMutation'
'SetPop'
'SetZiel'
:
:
:
:
- 'Start'
:
- 'Step'
- 'Stop'
:
:
Erklaert eine gespeicherte Matrix fur ungueltig
Erstellt eine neue Matrix
Zeichnet den Grafikbildschirm neu
Setzt den Generations-Zahler auf "1" zurueck
Ermittelt, wieviele Eltern am CrossOver teilnehmen
Setzen der Cross-Over Wahrscheinlichkeit
Setzen des zulaessigen Fehler fuer die Abbruchbedingung
Setzen der zulaessigen Generationen-Zahl fuer die
Abbruchbedingung
Setzen der zum Crossover angewandten Methode
Setzen der Mutations Wahrscheinlichkeit
Setzen der Anzahl der <Individuen> (Zeilenzahl der Matrix)
Setzen des Vergleichsvektors aus 3 verschiedenen Vorgaben
'0000 0000' oder '1111 1111' oder '0110 0100'(Default)
Initialisierungsteil. Wird bei Aufruf von GA_BIN.M ohne
Aufrufparameter <Action> ausgefuehrt
Eine Generation wird berechnet
Unterbrechen einer mit "Go" gestarteten
Generationsberechnung
Die Buttons und ihre Bedeutung
Step
:
Go
:
Stop
:
Restart:
Eine Generation berechnen (falls notwendig Matrix erzeugen)
Generationen berechnen (falls notwendig Matrix erzeugen)
'Go' unterbrechen
Mit gleicher Matrix und gleichem Zufallsgenerator
Programm auf "Anfang" setzen
: Matrix loeschen und neuer Stand des Zufallsgenerators
Programm auf "Anfang" setzen
: Programm beenden
New
Done
if nargin<1
clear all
Action='Start';
end
%% Ist kein Aufruf-Parameter angegeben, wars ein
%% User-Aufruf -> Das Programm starten
%% Usefull things
hold off
echo off
%% Globale Variablen-Liste
global fig
global info_fig
% Ausgabe-Fenster
% Info-Fenster
global
global
global
global
global
Cross_Slide
Fehler_Slide
Generation_Slide
Mutations_Slide
Popu_Slide
%
%
%
%
%
global
global
global
global
global
global
global
Cross_text
CrossOver_text
Fehler_text
Generation_text
Mutations_text
Popu_text
Ziel_text
% Texte zu Slidern und Popups
global
global
global
global
done_button
go_button
info_button
show_button
global
global
global
global
global
global
info_done_button
info_more_button
new_button
step_button
stop_button
restart_button
%
%
%
%
%
%
%
%
%
%
%
%
%
Slider:
Slider:
Slider:
Slider:
Slider:
Button:
Button:
Button:
Button:
Button:
Button:
Button:
Button:
Button:
Button:
CrossOver Gewichtung
Abbruchbedingung "zulaessigen Fehler"
Abbruchbedingung "letzte Generation"
Mutations Gewichtung
Groesse der Population
Beenden
Starten
Oeffnen des Info-Fensters
Anzeigen der Population im
Matlab-Fenster
Schliessen des Info-Fensters
Naechste Info-Seite anzeigen
Neustart
Eine Generation berechnen
Berechnung anhalten
Neustart mit Wiederherstellung des
letzten Zustandes des
Zufallsgenerators
Seite 122
Kapitel 14: Programm-Texte
global CrossOver_popup
global Ziel_popup
% PopUp: Methode des CrossOvers auswaehlen
% PopUp: Ziel der Fitness-Funktion auswaehlen
global false
global true
% Booleans global bekannt machen
global AnzahlDerMutationen
global BitError
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
global CrossFaktor
global CrossOver_Methode
global Endbedingung
global
global
global
global
global
global
global
global
global
Fehlerkurve
fitness
GenerationsCntr
Individuen
InfoWindow
KinderAnteil
MatrixExists
MaxFehler
MaxGenerations
global MutationsCntr
global MutationsFaktor
global OneStep
global
global
global
global
global
global
global
p_eltern
p_kinder
p_speicher
process_cputime
RandomMerker
status
Ziel
Realzahl der noch durchzufuehrenden Mutationen
Anzahl der in einer Generation fehlerhaften
Bits
Anteil der am Crossover beteiligten Eltern
Methode, die Crossover anwendet
Abbruchbedingung fuer die
Generationsberechnung
Array mit Fitness-Werten vs. Generationenzahl
Nummer der aktuellen Generation
Anzahl der simulierten Individuen
fuer die Auswahl des aktiven Info-Fensters
Boolean Variable
Abbruchbedingung:
"letzte zu simulierende Generation"
Anzahl der aufgetretenen Mutationen
Status-Varialble:
Nur eine Generation simulieren
Die Eltern der aktuellen Generation
Die Kinder der aktuellen Generation
Merker: Startpopulation fuer Re-Start
Merker: CPU-Zeit zur Startzeit der Simulation
Merker des Startwertes des Randomgenerators
String, der in der Statuszeile angezeigt wird
Zielfunktion
%---------------- Action = Start
if strcmp(Action,'Start')
%% Vorbelegungen
Individuen
MaxGenerations
MaxFehler
= 20;
= 15;
= 0;
CrossFaktor
MutationsFaktor
fitness
GenerationsCntr
Ziel
Popu_Slide
darkgray
MutationsCntr
true
false
Endbedingung
OneStep
MatrixExists
status
CrossOver_Methode
InfoWindow
=
=
=
=
=
=
=
=
=
=
=
=
=
=
1;
0.001;
0;
1;
[0 1 1 0 0 1 0 0];
Individuen;
[1/3 1/3 1/3];
0;
1;
0;
false;
false;
false;
'Waiting for Userinput';
= 1;
= 0;
%% Fenster anlegen
fig=clf;
set(gcf,'Units','normalized','backingstore','off', ...
'name','Binaerer GA','NumberTitle','off');
figure(fig)
%% Buttons anlegen
step_button = ...
uicontrol('style','Pushbutton','Position', [.02 .02 .12 .08], ...
'Units','normalized', 'Callback','ga_bin(''Step'')', ...
'String','Step');
Seite 123
Kapitel 14: Programm-Texte
go_button = ...
uicontrol('style','Pushbutton','Position', [.14 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','ga_bin(''Go'')','String','Go','Visible','on');
stop_button = ...
uicontrol('style','Pushbutton','Position', [.26 .02 .12 .08], ...
'Units','normalized','Callback','ga_bin(''Stop'')', ...
'String','Stop');
show_button = ...
uicontrol('style','Pushbutton','Position', ...
[.38 .02 .12 .08],'Units','normalized', ...
'Callback','ga_bin(''Show'')','String','Show');
info_button = ...
uicontrol('style','Pushbutton','Position', ...
[.50 .02 .12 .08],'Units','normalized', ...
'Callback','ga_bin(''Info'')','String','Info');
restart_button = ...
uicontrol('style','Pushbutton','Position', [.62 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','ga_bin(''Restart'')', ...
'String','Restart','Visible','off');
new_button = ...
uicontrol('style','Pushbutton','Position',[.74 .02 .12 .08], ...
'Units','normalized','Callback','ga_bin(''New'')', ...
'String','New');
done_button = ...
uicontrol('style','Pushbutton','Position',[.86 .02 .12 .08], ...
'Units','normalized','Callback','ga_bin(''done'')', ...
'String','Done');
%% Sliders mit Texten anlegen
Popu_Slide= ...
uicontrol('style','slider','Position',[.02 .15 .25 .03],...
'Units','normal','Value',Individuen,'Max',50,'Min',12,...
'Callback','ga_bin(''SetPop'')');
Popu_text = ...
uicontrol('style','text','units','normal','pos',[.02 .18 .25 .04], ...
'string',[num2str(Individuen),' Indiviuden'],'fore', ...
'white','back',darkgray, 'HorizontalAlignment','left');
Fehler_Slide= ...
uicontrol('style','slider','Position',[.02 .39 .25 .03],...
'Units','normal','Value',MaxFehler,'Max',50,'Min',0,...
'Callback','ga_bin(''SetFehler'')');
Fehler_text = ...
uicontrol('style','text','units','normal','pos',[.02 .42 .25 .04], ...
'string',['Fehler Ziel: ',num2str(MaxFehler)], ...
'fore','white','back',darkgray, 'HorizontalAlignment','left');
Generation_Slide= ...
uicontrol('style','slider','Position',[.02 .27 .25 .03],...
'Units','normal','Value',MaxGenerations,'Max',100,'Min',10,...
'Callback','ga_bin(''SetMaxGen'')');
Generation_text = ...
uicontrol('style','text','units','normal','pos',[.02 .30 .25 .04], ...
'string',['Last Generation ',num2str(MaxGenerations)], ...
'fore','white', ...
'back',darkgray,'HorizontalAlignment','left');
Cross_Slide= ...
uicontrol('style','slider','Position',[.67 .15 .25 .03],...
'Units','normal','Value',CrossFaktor,'Max',1,'Min',0.01,...
'Callback','ga_bin(''SetCrossFaktor'')');
Cross_text = ...
uicontrol('style','text','units','normal','pos',[.67 .18 .25 .04], ...
'string',['Cross Over ',num2str(CrossFaktor*100),'%'], ...
'fore','white', ...
'back',darkgray, 'HorizontalAlignment','left');
Mutations_Slide= ...
uicontrol('style','slider','Position',[.67 .27 .25 .03],...
'Units','normal','Value',MutationsFaktor,'Max',0.03, ...
'Min',0,'Callback','ga_bin(''SetMutation'')');
Mutations_text = ...
Seite 124
Kapitel 14: Programm-Texte
uicontrol('style','text','units','normal','pos',[.67 .30 .25 .04], ...
'string',['Mutation ',num2str(MutationsFaktor*100),'%'], ...
'fore','white','back',darkgray,'HorizontalAlignment','left');
%% Pop-Ups mit Texten anlegen
Ziel_popup = ...
uicontrol('Style','Popup','String','0110 0100|1111 1111|0000 0000',...
'Position',[.34 .17 .2 .08],'Units','normalized',...
'CallBack','ga_bin(''SetZiel'')');
Ziel_text = ...
uicontrol('style','text','units','normal','pos',[.34 .23 .2 .04], ...
'string','Ziel-Vorgabe','fore','white', ...
'back',darkgray,'HorizontalAlignment','left');
CrossOver_popup = ...
uicontrol('style','Popup','String','Methode 1|Methode 2',...
'Position',[.34 .36 .2 .08],'Units','normalized',...
'CallBack','ga_bin(''SetMethode'')');
CrossOver_text = ...
uicontrol('style','text','units','normal','pos',[.34 .42 .2 .04], ...
'string','Restart with','fore','white', ...
'back',darkgray,'HorizontalAlignment','left');
%% Random Generatoren Status merken
RandomMerker = rand('seed');
ga_bin('SetZiel')
ga_bin('SetCrossAnteile')
ga_bin('Redraw')
end % Action=Start
%-------------------- Action = Redraw
if strcmp(Action,'Redraw')
figure(fig)
subplot(2,1,1)
plot(Fehlerkurve)
xlabel(['Generation (',num2str(GenerationsCntr),')'])
ylabel(['Fehler in Bits (',num2str(BitError),')'])
title(status)
figtext(.67,.41,['Mutationen: ',num2str(MutationsCntr)])
figtext(.67,.46,['CPU Time : ',num2str(cputime-process_cputime),' s'])
drawnow
end % Action=Redraw
%-------------------- Action = RandomMatrix
if strcmp(Action,'RandomMatrix');
% Es wird eine Matrix mit einer zufaelligen
% Verteilung von "1" und "0" generiert
% Eine ganze Nummer kuerzer und schneller
% waere: p_eltern=randn(Individuen,8)<0
% aber die besten Ideen kommen einem manchmal
% erst viel spaeter und weil diese Loesung
% auch nicht schadet, bleibt sie drin
p_eltern = randn(Individuen,8);
for i = 1:Individuen,
for j = 1:8,
if(p_eltern(i,j)) >=0 p_eltern(i,j)=1;
else
p_eltern(i,j)=0;
end % if
end % for j
end % for i
MatrixExists = true;
end % Action=RandomMatrix
%-------------------- Action = SetPop / Slider auslesen
if strcmp(Action,'SetPop')
status
= 'Waiting for Userinput';
Individuen
= 4*(round(round(get(Popu_Slide,'Value'))/4));
MatrixExists
= false;
GenerationsCntr = 1;
Fehlerkurve
= [];
p_eltern
= [];
p_kinder
= [];
Seite 125
Kapitel 14: Programm-Texte
p_speicher
= [];
fitness
= [];
BitError
= 0;
MutationsCntr
= 0;
set(restart_button,'Visible','off');
set(Popu_text,'string',[num2str(Individuen),' Individuen'])
ga_bin('SetCrossAnteile')
end % Action=SetPop
%-------------------- Action = SetMaxGen / Slider auslesen
if strcmp(Action,'SetMaxGen')
status
= 'Waiting for Userinput';
MaxGenerations = round(get(Generation_Slide,'Value'));
set(Generation_text,'string',['Last Generation ',num2str(MaxGenerations)])
end % Action=SetMaxGen
%-------------------- Action = SetFehler / Slider auslesen
if strcmp(Action,'SetFehler')
status
= 'Waiting for Userinput';
MaxFehler = round(get(Fehler_Slide,'Value'));
set(Fehler_text,'string',['Fehler Ziel: ',num2str(MaxFehler)])
end % Action=SetFehler
%-------------------- Action = SetCrossFaktor / Slider auslesen
if strcmp(Action,'SetCrossFaktor')
status
= 'Waiting for Userinput';
CrossFaktor = (round((get(Cross_Slide,'Value'))*100))/100;
set(Cross_text,'string',['Cross Over ',num2str(CrossFaktor*100),'%'])
ga_bin('SetCrossAnteile');
end % Action=SetCrossFaktor
%-------------------- Action = SetMutation / Slider auslesen
if strcmp(Action,'SetMutation')
status
= 'Waiting for Userinput';
MutationsFaktor = (get(Mutations_Slide,'Value'));
set(Mutations_text,'string',['Mutation ',num2str(MutationsFaktor*100),'%'])
end % Action=SetMutation
%-------------------- Action = SetMethode / Pop-Up auslesen
if strcmp(Action,'SetMethode')
val = get(CrossOver_popup,'Value');
if
(val == 1), CrossOver_Methode=1;
elseif (val == 2), CrossOver_Methode=2;
end;
set(restart_button,'Visible','off');
ga_bin('Restart')
end % Action=SetMaxGen
%-------------------- Action = SetZiel
if strcmp(Action,'SetZiel')
status = 'Waiting for Userinput';
val
= get(Ziel_popup,'Value');
if
(val == 1), Ziel=[0 1 1 0 0 1
elseif (val == 2), Ziel=[1 1 1 1 1 1
elseif (val == 3), Ziel=[0 0 0 0 0 0
end;
end % Action=SetZiel
/ Pop-Up auslesen
0 0];
1 1];
0 0];
%------------------- Action = SetCrossAnteile
if strcmp(Action,'SetCrossAnteile')
KinderAnteil = round(CrossFaktor*Individuen);
end % Action=SetCrossAnteile
%-------------------- Action = Go
if strcmp(Action,'Go')
set(restart_button,'Visible','on')
Endbedingung = false;
OneStep
= false;
status
= 'Selected Option: Go';
if MatrixExists==false
ga_bin('RandomMatrix')
p_speicher
= p_eltern;
Fehlerkurve
= [];
GenerationsCntr = 1;
Seite 126
Kapitel 14: Programm-Texte
MutationsCntr
= 0;
process_cputime = cputime;
end % if MatrixExists
ga_bin('Redraw');
%% Hier wird die eigentliche Simulation aufgerufen.
%% Es haette auch innerhalb der Simulation zwischen den beiden Methoden
%% unterschieden werden koennen, um aber eine Bevorzugung bei der CPU-Zeit%% Ermittlung, wie sie in einem "IF THEN ELSE"-Konstrukt vorkommt, zu
%% entgehen wurde dieser (mit redundatem Code) verbundene Weg gewaehlt.
if
CrossOver_Methode ==1 ga_bin('Loop_Methode1')
elseif CrossOver_Methode ==2 ga_bin('Loop_Methode2')
end % if
end % Action=Go
%-------------------- Action = Stop
if strcmp(Action,'Stop')
status
= 'Selected Option: Stop, then waiting for Userinput';
Endbedingung = true;
ga_bin('Redraw')
end % Action=Stop
%-------------------- Action = New
if strcmp(Action,'New')
status
= 'Matrix killed. Waiting for Userinput';
MatrixExists
= false;
GenerationsCntr = 1;
Fehlerkurve
= [];
BitError
= 0;
MutationsCntr
= 0;
process_cputime = cputime;
set(restart_button,'Visible','off')
ga_bin('Redraw')
end % Action=New
%-------------------- Action = Step
if strcmp(Action,'Step')
OneStep = true;
if MatrixExists==false
ga_bin('RandomMatrix')
set(restart_button,'Visible','on')
p_speicher
= p_eltern;
Fehlerkurve
= [];
GenerationsCntr = 1;
MutationsCntr
= 0;
else
Endbedingung = false;
end % if MatrixExists
status = 'Selected Option: One Step, then waiting for Userinput';
ga_bin('Redraw')
%% Hier wird die eigentliche Simulation aufgerufen.
%% Es haette auch innerhalb der Simulation zwischen den beiden Methoden
%% unterschieden werden koennen, um aber eine Bevorzugung bei der CPU-Zeit%% Ermittlung wie sie in einem "IF THEN ELSE"-Konstrukt vorkommt zu entgehen
%% wurde dieser (mit redundatem Code) verbundene Weg gewaehlt.
if
CrossOver_Methode ==1 ga_bin('Loop_Methode1')
elseif CrossOver_Methode ==2 ga_bin('Loop_Methode2')
end % if
end % Action=Step
%-------------------- Action = Restart
if strcmp(Action,'Restart')
Endbedingung
= false;
BitError
= 0;
Fehlerkurve
= [];
p_eltern
= p_speicher;
GenerationsCntr = 1;
MutationsCntr
= 0;
rand('seed',RandomMerker);
status='Generation Counter reset, waiting for Userinput';
% Damit nichts verwirrendes angezeigt wird ...
process_cputime = cputime;
ga_bin('Redraw')
% und dann nochmal, damit die Rechnung auch stimmt...
process_cputime = cputime;
Seite 127
Kapitel 14: Programm-Texte
end % Action=Restart
%-------------------- Action = Loop
if strcmp(Action,'Loop_Methode1')
while (GenerationsCntr<=MaxGenerations)&(Endbedingung==false)
% Fitness berechnen
% Durch Vergleich der Gene eines Individuums mit der Ziel-Funktion
% wird die Anzahl der ubereinstimmenden Gene bestimmt.
% Daraus durch Subtraktion die Anzahl der "fehlerhaften" Gene -> Fitness
% Die Fitness des einzelnen Individuums wird im fitness-Array gespeichert
% und die Summe der Fitnesswerte der ganzen Generation in der Fehlerkurve
% vermerkt.
BitError = 0;
fitness = zeros(1,size(p_eltern,1));
for u = 1:size(p_eltern,1),
fitness(u) = 8-sum(p_eltern(u,:)==Ziel);
end %for u
% Selection der Besten. Anzahl fuer die Auswahl: <Individuen>
% Der Fehler in der selektierten Population wird in der
% <Fehlerkurve> vermerkt
% Ist der Restfehler <= dem zugelassenen Fehler wird die
% <Endbedingung> wahr.
p_kinder = zeros(Individuen,8);
[wert,index] = sort(fitness);
for u = 1:Individuen,
p_kinder(u,:) = p_eltern(index(u),:);
end % for u
BitError = sum(wert(1:Individuen));
Fehlerkurve(GenerationsCntr) = BitError;
if (BitError <= MaxFehler) Endbedingung = true;
% Abbruchbedingung noch nicht erreicht ...
else
% Cross Over der Besten
% Schema:
% Der Beste wird mit dem Zweitbesten gekreuzt
% Der Zweitbeste mit dem Drittbesten
% Der Drittbeste mit dem Viertbesten...
% Aus 2 Eltern entstehen 2 neue Kinder
%
% Aber zuerst wird einmal die Anzahl der entstehende Kinder berechnet:
% damit die Matrix p_kinder entsprechend auf einmal erweitert werden
% kann (spart enorm Rechenzeit -> "don't grow matrices")
if KinderAnteil>0
Anzahl = KinderAnteil-1;
p_kinder = [p_kinder; zeros(Anzahl ,8)];
EintragsZeiger = Individuen+1;
for u = 1:(KinderAnteil-1),
[p_kinder(EintragsZeiger,:),p_kinder(EintragsZeiger+1,:)] = ...
x_over(round(rand*7)+1, p_eltern(u,:),p_eltern(u+1,:));
EintragsZeiger = EintragsZeiger+2;
end % for u = 1:(KinderAnteil ....
end
% if KinderAnteil
% Mutation durch Bitinvertierung
% Ist die Variable <MutationsFaktor> groesser 0 finden Mutationen statt.
% Dazu wird mit <AnzahlDerMutationen> ueber die Anzahl der enstandenen
% Gene Buch gefuehrt. Entsprechend der eingestellten
% Mutations-Wahrscheinlichkeit <MutationsFaktor>
% werden dann per Zufall <AnzahlDerMutationen> Gene der zuvor
% generierten Individuen invertiert.
%
% Es werden zuvor genuegend Zufallszahlen fuer 100 % Mutation erzeugt,
% um bei wechselndem <MutationsFaktor> nicht durch einen unterschiedliche
% Anzahl an Abfragen von Zufallszahlen die Vergleichbarkeit zu
% beeinflussen.
%
MaxMutationen=round(0.04*size(p_kinder,1)*8+0.5);
MutationsIndividuum = round((rand(1,MaxMutationen)*(Individuen-1))+0.5);
MutationsChromosom = round((rand(1,MaxMutationen)*(8-1))+0.5);
if (MutationsFaktor>0)
Seite 128
Kapitel 14: Programm-Texte
AnzahlDerMutationen = MutationsFaktor*size(p_kinder,1)*8;
for i = 1:round(AnzahlDerMutationen),
p_kinder(MutationsIndividuum(i),MutationsChromosom(i)) = ...
~p_kinder(MutationsIndividuum(i),MutationsChromosom(i));
end % for i
MutationsCntr = MutationsCntr + round(AnzahlDerMutationen);
AnzahlDerMutationen = AnzahlDerMutationen - round(AnzahlDerMutationen);
end % if Mutationsfaktor
end % if (BitError <= MaxFehler) ...
% Kinder werden die neue Eltern-Generation
p_eltern = p_kinder;
ga_bin('Redraw')
GenerationsCntr = GenerationsCntr+1;
if (OneStep == true) Endbedingung = true;
end % if OneStep
end
% while GenerationsCntr<=MaxGenerations
end
% Action=Loop
%-------------------- Action = Loop Methode 2
if strcmp(Action,'Loop_Methode2')
while (GenerationsCntr<=MaxGenerations)&(Endbedingung==false)
%
%
%
%
%
%
%
Fitness berechnen
Durch Vergleich der Gene eines Individuums mit der Ziel-Funktion
wird die Anzahl der ubereinstimmenden Gene bestimmt.
Daraus durch Subtraktion die Anzahl der "fehlerhaften" Gene -> Fitness
Die Fitness des einzelnen Individuums wird im fitness-Array gespeichert
und die Summe der Fitnesswerte der ganzen Generation in der Fehlerkurve
vermerkt.
BitError = 0;
fitness = zeros(1,size(p_eltern,1));
for u = 1:size(p_eltern,1),
fitness(u) = 8-sum(p_eltern(u,:)==Ziel);
end %for u
% Selection der Besten. Anzahl fuer die Auswahl: <Individuen>
% Der Fehler in der selektierten Population wird
% in der <Fehlerkurve> vermerkt
% Ist der Restfehler <= dem zugelassenen Fehler wird die
% <Endbedingung> wahr.
p_kinder = zeros(Individuen,8);
[wert,index] = sort(fitness);
for u = 1:Individuen,
p_kinder(u,:) = p_eltern(index(u),:);
end % for u
BitError = sum(wert(1:Individuen));
Fehlerkurve(GenerationsCntr) = BitError;
if (BitError <= MaxFehler) Endbedingung = true;
% Abbruchbedingung noch nicht erreicht ...
else
% Cross Over der Besten
% Schema:
% Der Beste wird mit allen anderen Individuen gekreuzt
% Der Zweitbeste mit allen schlechteren Individuen
% Der Drittbeste mit allen schlechteren Individuen ...
% Aus 2 Eltern entstehen 2 neue Kinder
%
% Aber zuerst wird einmal die Anzahl der entstehende Kinder berechnet:
% damit die Matrix p_kinder entsprechend auf einmal erweitert werden
% kann (spart enorm Rechenzeit -> "don't grow matrices")
Anzahl = 0;
for u = 1:(KinderAnteil-1),
Anzahl = Anzahl+(2*u);
end % for u
Anzahl = (2*Anzahl)-(2*KinderAnteil)-1;
p_kinder = [p_kinder; zeros(Anzahl ,8)];
PartnerZeiger = 2;
Seite 129
Kapitel 14: Programm-Texte
EintragsZeiger = Individuen+1;
for u = 1:KinderAnteil,
for j = PartnerZeiger:(KinderAnteil-1),
[p_kinder(EintragsZeiger,:),p_kinder(EintragsZeiger+1,:)] = ...
x_over(round(rand*7)+1, p_eltern(u,:), p_eltern(j,:));
EintragsZeiger = EintragsZeiger+2;
end % for j
end % for u
% Mutation durch Bitinvertierung
% Ist die Variable <MutationsFaktor> groesser 0 finden Mutationen statt.
% Dazu wird mit <AnzahlDerMutationen> ueber die Anzahl der enstandenen
% Gene Buch gefuehrt. Entsprechend der eingestellten
% Mutations-Wahrscheinlichkeit <MutationsFaktor>
% werden dann per Zufall <AnzahlDerMutationen> Gene der zuvor
% generierten Individuen invertiert.
%
% Es werden zuvor genuegend Zufallszahlen fuer 100 % Mutation erzeugt,
% um bei wechselndem <MutationsFaktor> nicht durch einen unterschiedliche
% Anzahl an Abfragen von Zufallszahlen die Vergleichbarkeit
% zu beeinflussen.
%
MaxMutationen=round(0.04*size(p_kinder,1)*8+0.5);
MutationsIndividuum = round((rand(1,MaxMutationen)*(Individuen-1))+0.5);
MutationsChromosom = round((rand(1,MaxMutationen)*(8-1))+0.5);
if (MutationsFaktor>0)
AnzahlDerMutationen = MutationsFaktor*size(p_kinder,1)*8;
for i=1:round(AnzahlDerMutationen),
p_kinder(MutationsIndividuum(i),MutationsChromosom(i)) = ...
~p_kinder(MutationsIndividuum(i),MutationsChromosom(i));
end % for i
MutationsCntr = MutationsCntr + round(AnzahlDerMutationen);
AnzahlDerMutationen = AnzahlDerMutationen - round(AnzahlDerMutationen);
end % if Mutationsfaktor
end % if (BitError <= MaxFehler) ...
% Kinder werden die neue Eltern-Generation
p_eltern = p_kinder;
ga_bin('Redraw')
GenerationsCntr=GenerationsCntr+1;
if (OneStep == true) Endbedingung=true;
end % if OneStep
end
% while GenerationsCntr<=MaxGenerations
end
% Action=Loop
%-------------------- Action = Show
if strcmp(Action,'Show')
if ~(p_eltern==[])
disp(' ');
disp(['aktuelle Populationen der ',num2str(GenerationsCntr), ...
'.ten Generation:']);
disp(' ');
disp('Eltern-Generation:');
p_eltern(1:Individuen,:)
else
disp(' ');
disp('Noch liegen keine Daten vor.');
disp('Benutzen Sie zuerst "STEP" oder "GO" !');
end % if ~(p_eltern==[])
return
end % Action = Show
%-------------------- Action = Info
if strcmp(Action,'Info')
if InfoWindow==0
info_fig=figure('name','Info','NumberTitle','off');
InfoWindow=1;
end % If InfoWindow==0
clf;
%% Fenster oeffnen
%% und Button fuer das Schliessen des Fensters einfuegen
info_done_button=uicontrol('Style','Pushbutton', ...
'Position',[.84 .02 .12 .08],'Units','normalized', ...
Seite 130
Kapitel 14: Programm-Texte
'Callback','ga_bin(''InfoDone'')','String','Close');
info_more_button=uicontrol('Style','Pushbutton', ...
'Position',[.70 .02 .12 .08],'Units','normalized', ...
'Callback','ga_bin(''InfoMore'')','String','More');
%% Izt der Text ...
if InfoWindow==1
figtext(.02,.94, ...
'Info-Fenster "Binaerer genetischer Algorithmus":')
figtext(.02,.88, ...
'Ziel diese Matlab-Programmes ist es, die Funktion des Cross-Overs und')
figtext(.02,.84, ...
'der Mutation bei Genetischen Algorithmen zu demonstrieren.')
figtext(.02,.80, ...
'Die Ziel-Vorgabe ist eine Bitkombination, die fuer ein Individuum die')
figtext(.02,.76, ...
'ideale Anpassung an den "Lebensraum" bedeuten. Diese Bitkombination in')
figtext(.02,.72, ...
'den eigenen Genen so genau wie moeglich wiederzugeben, ist das Ziel,')
figtext(.02,.68, ...
'das bei der Simulation der Generationen verfolgt wird. Es werden aus')
figtext(.02,.64, ...
'den zufaellig generierten Genen der 1. Eltern-Generation (ebenfalls eine')
figtext(.02,.60, ...
'Bitkomination) durch CrossOver ("mischen von Genen") neue Bit-')
figtext(.02,.56, ...
'kombinationen erzeugt (ein "Kind"), die sich dann zusammen mit')
figtext(.02,.52, ...
'ihren Eltern auf ihre Anpassung auf den Lebensraum testen lassen')
figtext(.02,.48, ...
'muessen. Die am Besten angepassten Individuen bilden dann die Eltern')
figtext(.02,.44,...
'fuer die naechste zu simulierende Generation ("Selektion").')
figtext(.02,.40, ...
'Die Kurve im oberen Teil des Haupt-Fensters gibt an, wieviele Bits')
figtext(.02,.36, ...
'der "Gene" der gesammten Population noch nicht mit der Ziel-Vorgabe')
figtext(.02,.32,'uebereinstimmen.')
figtext(.02,.28, ...
'Die Mutation ist eine zufaellige Stoerung. Hier werden einzelne Bits')
figtext(.02,.24, ...
'der Gene invertiert. Bei zu grossen Mutations-Einfluessen kann die')
figtext(.02,.20,'Entropie ueber der Generationenzahl auch ansteigen !')
elseif InfoWindow==2
figtext(.02,.94, ...
'Die Oberflaeche des Programms:');
figtext(.02,.88, ...
'Im oberen Teil des Fensters ist die Anzahl der fehlerhaften Bits ueber
der');
figtext(.02,.84, ...
'Generationenzahl dargestellt.');
figtext(.02,.80, ...
'');
figtext(.02,.76, ...
'Schieberegler "Fehler Ziel": Zulaessige Anzahl an fehlerhaften Bits');
figtext(.02,.72, ...
'Schieberegler "Last Generation": Abbruchbedingung fuer die Simulation');
figtext(.02,.68, ...
'Schieberegler "Individuen": Anzahl der simulierten Individuen');
figtext(.02,.64, ...
'Pop-Up "Restart with": Crossover-Methode waehlen');
figtext(.02,.60, ...
'Pop-Up "Ziel-Vorgabe": Wahl des Ziel-Bitmusters');
figtext(.02,.56, ...
'Schieberegler "Mutation": Einstellen der Mutations-Wahrscheinlichkeit');
figtext(.02,.52, ...
'
(bei 100 % werden alle Bits invertiert)');
figtext(.02,.48, ...
'Schieberegler "Cross Over": Einstellen der Crossover-Wahrscheinlichkeit');
figtext(.02,.44, ...
'
(bei 100 % werden alle Eltern an der Fortpflanzung beteiligt)');
figtext(.02,.40, ...
'"Step"-Button: Eine Generation wird simuliert');
figtext(.02,.36, ...
Seite 131
Kapitel 14: Programm-Texte
'"Go"-Button: Simulation starten');
figtext(.02,.32, ...
'"Stop"-Button: Simulation anhalten');
figtext(.02,.28, ...
'"Restart"-Button: Simulation ruecksetzen(Zufallsgenerator wie bei letztem
Start)');
figtext(.02,.24, ...
'"New"-Button: Simulation ruecksetzen');
figtext(.02,.20, ...
'"Done"-Button: Programm beenden');
end % If InfoWindow==1
end % Action = Info
%-------------------- Action = InfoMore
if strcmp(Action,'InfoMore')
if InfoWindow==1
InfoWindow=2;
else InfoWindow=1;
end
ga_bin('Info')
end % Action = InfoDone;
%-------------------- Action = InfoDone
if strcmp(Action,'InfoDone')
InfoWindow=0;
close(info_fig)
end % Action = InfoDone;
%-------------------- Action = Done
if strcmp(Action,'done')
close;
%% fig
close;
%% fig_info, falls offen
clear all; %% Variablen freigeben
end % Action=Done
end
% GA_BIN.M
Seite 132
Kapitel 14: Programm-Texte
14.1.2 X_OVER.M von GA_BIN.M
Das Crossover bildet den Hauptmutations-Operator der genetischen Algorithmen.
Die zu tauschenden Matrizenteile werden zyklisch über einen als Speicher dienende Variable
("dummy") getauscht.
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
function X_OVER.M
Status: ( ) blocked
( ) testing
Last Revision: 22.09.95
IN:
(X) ready for use
(c) by Jan-Erik Engels
Zwei gleich grosse Vectoren und Information ueber
den Cross_over Punkt
Out: Zwei gleich grosse Vectoren, deren Stellen 1 bis
zum Cross_over Punkt getauscht sind
abgefangene Fehler:
- Ungleichheit der Vector-Dimensionen
- Cross_over Punkt ausserhalb der Vectoren
- keine Uebergabeparameter
function [vector1,vector2] = X_OVER(x_overPoint,vector1,vector2)
echo off
if nargin>0
if size(vector1,2)==size(vector2,2),
if x_overPoint<=size(vector1,2),
dummy=vector1(1:x_overPoint);
vector1(1:x_overPoint)=vector2(1:x_overPoint);
vector2(1:x_overPoint)=dummy;
end
% if x_overPoint
end
% if size
end
% if nargin
end
% function x_over
Seite 133
Kapitel 14: Programm-Texte
14.2 Das MATLAB-Programm ES_TSP.M
14.2.1 ES_TSP.M
Das ES_TSP stellt die programmtechnische Realisierung des Travelling Salesman Problems
dar.
Die eigentliche Simulation / Optimierung findet im Programmteil mit der Action „Loop" statt.
function es_tsp(Action)
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Funktion ES_TSP - Traveling Salesman Problem
als Evolutionaere Realsierung
Version 1.5 vom 21.01.1996 (c) Jan-Erik Engels 1995
Status: ( ) blocked
( ) testing
(X) ready for use
Beschreibung:
Beschreibung der Traveling Salesman Problematik: siehe Info-Fenster !!!
Loesungsrepraesentation des Problems:
Fuer eine Anzahl von <Individuen> wird die Reiseroute im Feld <Population_
Eltern> bzw. <Population_Kinder> als Abfolge von Staedte-Nummern dargestellt.
Ueber die 4 Schiebe-Regler <Exchange_Slide>, <Insert_Slide>,<Inversion_Slide>
und <Moving_Slide> wird bestimmt, welchen Anteil die einzelnen MutationsOperatoren an der Nachkommenschaft der Eltern bilden.
Aus dem Gen-Pool der Eltern und ihrer Nachkommen werden die besten Loesungen
(mit dem kuerzesten zueckgelegten Weg) in die naechste Elterngeneration
uebernommen.
%% Start Up
if nargin<1
clear all
Action='Start';
end % if nargin
%% Usefull things
echo off
%% Globale Variablen-Liste
%% Buttons
global Done_Button
global Go_Button
global New_Button
global Step_Button
global Stop_Button
global Restart_Button
%% Sliders
global Exchange_Slide
global Generation_Slide
global Insert_Slide
global Inversion_Slide
global Moving_Slide
global Population_Slide
%
%
%
%
%
%
%
%
%
Beenden des Matlab-Programmes
Starten der Simulation
Neustart des Programmes
Simulation einer Generation
Anhalten der Simulation
Neustart des Programmes, wobei
der Zufallsgenerator auf
wie bei letzten Start der Simulation
wiederhergestellt wird
%
%
%
%
%
%
Schieberegler
Schieberegler
Schieberegler
Schieberegler
Schieberegler
Schieberegler
fuer
fuer
fuer
fuer
fuer
fuer
%% Texte zu Sliders und Pop-Ups
global CareForClausel_text %
global Exchange_text
%
global Generation_text
%
global Insert_text
%
global Inversion_text
%
Seite 134
die
den
die
die
die
die
Exchange-Mutation
Abbruch "letzte Generation"
Insert-Mutation
Inversion-Mutation
Moving-Mutation
Anzahl der Individuen
Kapitel 14: Programm-Texte
global Moving_text
global Population_text
global ReiseZiel_text
%
%
%
%% Pop-Ups
global CareForClausel
global ReiseZiel
%
%
global true
global false
global
global
global
global
AverageWegKurve
BesterWegKurve
BesterWegPlot
CareFor
%
%
%
%
%
global CurrentInfoPage
%
global Endbedingung
%
global Exchange
%
%
global GenerationsCntr
%
global HalbePunkteZahl
%
global Individuen
%
global Info_Window
%
global InfoIsOpen
%
global Inversion
%
%
global Insert
%
global MainFigure
%
global MatrixExists
%
global MaxGenerations
%
global MinWeg
%
global MinWegIndex
%
global Moving
%
global PunktNummer
%
global OneStep
%
global Population_Eltern %
global Population_Kinder %
global Population_fitness %
global PunkteZahl
%
global RandomMerker
%
global Status
%
global SW
%
global Wege
%
%
global WegPlot
%
global x
%
global y
%
Kurve: Mittlere Fitness vs. Generationenzahl
Kurve: Bestes Individuum vs. Generationenzahl
Handle: Wegstrecke des derzeit besten Individuum
Bestimmt, ob Abbruchbedingungen beachtet
werden sollen
Zeigt auf die aktuelle Information-Seiten
Abbruchbedingung (wird aktive wenn "true")
Prozent-Anteil der Exchange-Mutation
an der Evolution
Zaehler
Anzahl der simulierten Individuen
Infobildschirm (Info-Texte zum Programm)
Boolean, wichtig fuer das Schliessen des Fensters
Prozent-Anteil der Inversion-Mutation
an der Evolution
Prozent-Anteil der Insert-Mutation an der Evolution
Hauptbildschirm (stellt die Simulation dar)
Boolean
Abbruchbedingung
Zahlenwert des derzeit kuerzesten Weges
Zeiger auf das derzeit beste Individuum
Prozent-Anteil der Moving-Mutation an der Evolution
Boolean: true -> Nur eine Generation simulieren
Die derzeitige Eltern-Generation
Die derzeitige Kinder-Generation
Liste der den Eltern zugeordneten Fitness-Werte
Anzahl der Staedte in der Simulation
Statusinformationen fuer den Benutzer
Liste der Schrittweiten
Liste mit den Weglaenge der aktuellen
Eltern-Generation
Handle: Grafik der Wege vs. Generationezahl
Wegedaten x-Richtung von WegPlot
Wegedaten y-Richtung von WegPlot
%---------------- Action = Start
% Wird aufgerufen, wenn ES_TSP ohne Action gestartet wird.
% Initialisiert Variablen, oeffnet das Ausgabefenster, legt die Buttons
% und Slider an und ruft die Action "SetDefault" auf.
if strcmp(Action,'Start')
true
= 1;
false
= 0;
es_tsp('SetDefaults')
%% Ausgabe-Fenster initialisieren
MainFigure = gcf;
clf
set(MainFigure,'name','Travelling Salesman','NumberTitle','off')
InfoIsOpen
= false;
CurrentInfoPage = 1;
%% Vorbelegungen
Exchange
Insert
Inversion
Moving
MaxGenerations
Individuen
SW
=
=
=
=
=
=
=
100;
100;
100;
100;
100;
21;
ones(Individuen,1);
Seite 135
Kapitel 14: Programm-Texte
%% Buttons
Step_Button = ...
uicontrol('Style','Pushbutton','Position',[.02 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','es_tsp(''Step'')','String','Step');
Go_Button = ...
uicontrol('Style','Pushbutton','Position',[.15 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','es_tsp(''Go'')','String','Go','Visible','on');
Stop_Button = ...
uicontrol('Style','Pushbutton','Position',[.28 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','es_tsp(''Stop'')','String','Stop');
info_button = ...
uicontrol('Style','Pushbutton','Position',[.44 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','es_tsp(''Info'')','String','Info');
Restart_Button = ...
uicontrol('Style','Pushbutton','Position',[.60 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','es_tsp(''Restart'')','String','Restart', ...
'Visible','off');
New_Button = ...
uicontrol('Style','Pushbutton','Position',[.73 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','es_tsp(''New'')','String','New');
Done_Button = ...
uicontrol('Style','Pushbutton','Position',[.86 .02 .12 .08], ...
'Units','normalized','interruptible','yes', ...
'Callback','es_tsp(''done'')','String','Done');
%% Sliders und Texte anlegen
Generation_Slide= ...
uicontrol('Style','slider','Position',[.02 .27 .28 .03],...
'Units','normal','Value',MaxGenerations,'Max',2000,'Min',10,...
'interruptible','yes','Callback','es_tsp(''SetMaxGen'')');
Generation_text = ...
uicontrol('style','text','units','normal','pos',[.02 .30 .28 .04], ...
'string',['Last Generation ',num2str(MaxGenerations)], ...
'fore','white','HorizontalAlignment','left');
Population_Slide= ...
uicontrol('Style','slider','Position',[.02 .15 .28 .03],...
'Units','normal','Value',Individuen,'Max',200,'Min',12,...
'interruptible','yes','Callback','es_tsp(''SetPop'')');
Population_text = ...
uicontrol('style','text','units','normal','pos',[.02 .18 .28 .04], ...
'string',[num2str(Individuen),' Individuen'], ...
'fore','white','HorizontalAlignment','left');
Exchange_Slide= ...
uicontrol('Style','slider','Position',[.35 .15 .28 .03],...
'Units','normal','Value',Exchange,'Max',100,'Min',0,...
'interruptible','yes','Callback','es_tsp(''SetExchange'')');
Exchange_text = ...
uicontrol('style','text','units','normal','pos',[.35 .18 .28 .04], ...
'string',['Exchange ',num2str(Exchange),' %'], ...
'fore','white','HorizontalAlignment','left');
Moving_Slide= ...
uicontrol('Style','slider','Position',[.35 .27 .28 .03],...
'Units','normal','Value',Moving,'Max',100,'Min',0,...
'interruptible','yes','Callback','es_tsp(''SetMoving'')');
Moving_text = ...
uicontrol('style','text','units','normal','pos',[.35 .30 .28 .04], ...
'string',['Moving ',num2str(Moving),' %'], ...
'fore','white','HorizontalAlignment','left');
Insert_Slide= ...
uicontrol('Style','slider','Position',[.68 .15 .28 .03],...
'Units','normal','Value',Insert,'Max',100,'Min',0,...
'interruptible','yes','Callback','es_tsp(''SetInsert'')');
Seite 136
Kapitel 14: Programm-Texte
Insert_text = ...
uicontrol('style','text','units','normal','pos',[.68 .18 .28 .04], ...
'string',['Insert ',num2str(Insert),' %'],'fore','white', ...
'HorizontalAlignment','left');
Inversion_Slide= ...
uicontrol('Style','slider','Position',[.68 .27 .28 .03],...
'Units','normal','Value',Inversion,'Max',100,'Min',0, ...
'interruptible','yes','Callback','es_tsp(''SetInversion'')');
Inversion_text = ...
uicontrol('style','text','units','normal','pos',[.68 .30 .28 .04], ...
'string',['Inversion ',num2str(Inversion),' %'], ...
'fore','white','HorizontalAlignment','left');
%% Pop-Ups und Texte anlegen
ReiseZiel=uicontrol ...
('Style','Popup','String', ...
'Circle 19.66m|AE 37.67m|BE 46.55m|User def.','interruptible','yes', ...
'Position',[.76 .38 .2 .07],'Units','normalized', ...
'CallBack','es_tsp(''SetReise'');es_tsp(''Redraw'')');
ReiseZiel_text = ...
uicontrol('style','text','units','normal','pos',[.76 .44 .2 .07], ...
'string','Route:','fore','white', ...
'HorizontalAlignment','left');
CareForClausel=uicontrol ...
('Style','Popup','String','When done|Never','interruptible','yes', ...
'Position',[.50 .38 .2 .07],'Units','normalized', ...
'CallBack','es_tsp(''SetCareForClausel'');es_tsp(''Redraw'')');
CareForClausel_text = ...
uicontrol('style','text','units','normal','pos',[.50 .44 .2 .07], ...
'string','Stop:','fore','white', ...
'HorizontalAlignment','left');
%% Random Merker
RandomMerker=rand('seed');
es_tsp('SetReise')
es_tsp('WegeBerechnen')
BesterWegKurve(GenerationsCntr)=MinWeg;
es_tsp('Redraw')
end % Action=Start
%-------------------- Action = SetDefaults
% Wird von der Action "Start" und "New" aufgerufen und belegt
% verschiedene Variablen mit Default-Werten.
if strcmp(Action,'SetDefaults')
Population_Kinder = [];
BesterWegKurve
= [];
AverageWegKurve
= [];
Wege
= [];
Population_fitness= [];
GenerationsCntr
= 1;
Endbedingung
= false;
OneStep
= false;
MatrixExists
= false;
Status
= 'Waiting for Userinput';
CareFor
= true;
SW
= ones(Individuen,1);
end % Action=SetDefaults
%-------------------- Action = Redraw
% Wird waehrend der Simulation von der Action "Loop" aufgerufen
% und zeichnet die Weglaengen über der Generationenzahl und den
% Weg des derzeit besten Individuums im Ausgabefenster neu.
if strcmp(Action,'Redraw')
figure(MainFigure)
delete(WegPlot)
WegPlot = subplot(2,2,2);
title([num2str(MinWeg),' m / ',num2str(PunkteZahl),' Objects'])
axis([0 10 0 10])
line(x(Population_Kinder(:,MinWegIndex)), ...
y(Population_Kinder(:,MinWegIndex)))
% Weil auch unter Matlab 4.0 gearbeitet wurde, konnte
Seite 137
Kapitel 14: Programm-Texte
% >> x=(1:1:GenerationsCntr);
% >> plot(x, [BesterWegKurve AverageWegKurve]);
% nicht angewandt werden
BesterWegPlot=subplot(2,2,1);
hold on
plot(BesterWegKurve,'y')
plot(AverageWegKurve,'g')
xlabel(['Generation (',num2str(GenerationsCntr),')'])
ylabel('Distance (m)')
title(Status)
figtext(.02,.45,...
['Mean Fitness: ',num2str(Population_fitness),' m (green)'])
figtext(.02,.40, ...
['Mean Stepsize: ',num2str(mean(SW(1:Individuen)))]);
hold off
drawnow
end % Action=Redraw
%-------------------- Action = ReiseMatrix
% Die Gene aller Individuen werden mit einer vorgegebenen
% Reiseroute vorbelegt (alle mit der gleichen Route)
% -> Ausgangssituation vor Start
if strcmp(Action,'ReiseMatrix')
Status = 'Waiting for Userinput';
Population_Eltern = zeros(PunkteZahl,Individuen);
Population_Kinder = zeros(PunkteZahl,Individuen);
for i=1:Individuen,
Population_Eltern(:,i) = PunktNummer(:);
Population_Kinder(:,i) = PunktNummer(:);
end % for i
MinWegIndex = 1;
MatrixExists = true;
end % Action=ReiseMatrix
%-------------------- Action = SetCareForClausel / Pop-Up auswerten
% Wird immer dann aufgerufen, wenn der Benutzer den Pop-Up
% "Stop" veraendert. Setzt die Variable "CareFor".
if strcmp(Action,'SetCareForClausel')
val = get(CareForClausel,'Value');
if
(val==1) CareFor = true;
elseif (val==2) CareFor = false;
end % if
end % Action=SetCareForClausel
%-------------------- Action = SetReise / Pop-Up auswerten
% Wird immer dann aufgerufen, wenn der Benutzer den
% Pop-Up "Route" veraendert. Ruft entsprechend der
% Auswahl durch den Benutzer die Actions "ReiseKreis",
% "ReiseAE", "ReiseBE" oder "ReiseBenutzer" auf.
% Die von diesen Actions uebergebene Reiseroute wird
% mit der Action "ReiseMatrix" allen Individuen uebergeben
% und mit der Action "WegeBerechnen" wird allen Individuen
% ein erster Fitness-Wert zugeordnet.
if strcmp(Action,'SetReise')
es_tsp('SetDefaults')
Status = 'Waiting for Userinput';
val = get(ReiseZiel,'Value');
if
(val == 1),
% Kreis
es_tsp('ReiseKreis')
elseif (val == 2),
% "AE"
es_tsp('ReiseAE')
elseif (val == 3),
% "BE"
es_tsp('ReiseBE')
elseif (val == 4),
% Benuzterdefiniert
es_tsp('ReiseBenutzer')
end; % if (val == ...
es_tsp('WegeBerechnen')
BesterWegKurve(1) = MinWeg;
AverageWegKurve(1) = MinWeg;
delete(BesterWegPlot)
BesterWegPlot = subplot(2,2,1);
end % Action=SetReise
Seite 138
Kapitel 14: Programm-Texte
%-------------------- Action = ReiseKreis
% Belegt die Reiseroute mit einer kreisfoermigen Reiseroute
% vor. Die X- und Y-Koordinaten dieser Route sind
% dabei als Konstanten vordefiniert. Es handelt sich bei dieser
% Reiseroute um ein 12-Staedte Problem.
if strcmp(Action,'ReiseKreis')
x = [1.8; 7.9; 5.0; 5.0; 2.3; 3.5; 6.5; 7.5; 7.5; 6.5; 3.5; 2.3;];
y = [5.1; 4.9; 0.8; 8.8; 7.1; 8.4; 8.2; 6.8; 2.9; 1.5; 1.4; 3.2;];
PunktNummer = [1;2;3;4;5;6;7;8;9;10;11;12;];
PunkteZahl = 12;
HalbePunkteZahl= 6;
es_tsp('ReiseMatrix')
end % Action=ReiseKreis
%-------------------- Action = ReiseAE
% Belegt die Reiseroute mit einer Reiseroute, die die
% Buchstabenfolge "AE" darstellt, vor. Die X- und
% Y-Koordinaten dieser Route sind dabei als Konstanten
% vordefiniert. Es handelt sich bei dieser Reiseroute um ein
% 27-Staedte Problem.
if strcmp(Action,'ReiseAE')
x =[1.1; 4.0; 2.4; 1.7; 3.6; 2.0; 3.2; 1.4; 3.8; 2.7; 5.9; ...
5.4; 5.4; 5.4; 5.4; 5.4; 5.4; 5.4; 6.5; 7.7; 8.6; 6.2; ...
7.2; 6.3; 7.3; 8.4; 9.4;];
y =[1.0; 1.0; 9.0; 4.7; 4.7; 7.0; 7.1; 3.0; 2.8; 4.8; 1.0; ...
0.7; 1.9; 3.1; 4.6; 5.7; 7.2; 8.6; 8.8; 8.8; 8.9; 4.7; ...
4.8; 0.7; 0.8; 0.8; 0.7;];
PunktNummer = [ 1; 2; 3; 4; 5; 6; 7; 8; 9;10;11;12;13;14;15; ...
16;17;18;19;20;21;22;23;24;25;26;27;];
PunkteZahl = 27;
HalbePunkteZahl = 13;
es_tsp('ReiseMatrix')
end % Action=ReiseAE
%-------------------- Action = ReiseBE
% Belegt die Reiseroute mit einer Reiseroute, die die
% Buchstaben "BE" darstellt, vor. Die X- und
% Y-Koordinaten dieser Route sind dabei als Konstanten
% vordefiniert. Es handelt sich bei dieser Reise-Route
% um ein 84-Staedte Problem.
if strcmp(Action,'ReiseBE')
x =[1.1; 1.5; 5.9; 6.5; 7.0; 8.6; 8.1; 7.7; 6.1; 8.4; 8.6; 7.8; 6.2; ...
6.0; 7.3; 8.1; 6.8; 7.4; 6.3; 6.6; 5.8; 5.9; 2.3; 3.2; 3.7; 3.5; ...
3.7; 3.2; 3.4; 2.6; 2.8; 6.1; 2.2; 6.1; 2.0; 6.0; 3.4; 1.6; 3.6; ...
0.9; 8.9; 0.9; 9.0; 0.8; 4.5; 9.1; 1.2; 0.8; 0.9; 0.9; 3.1; 7.1; ...
8.8; 0.8; 2.6; 6.1; 8.1; 0.9; 0.8; 0.9; 0.9; 2.1; 4.1; 5.1; 5.8; ...
6.6; 7.8; 7.2; 6.0; 5.8; 6.0; 6.0; 6.0; 6.3; 7.3; 1.5; 0.9; 1.0; ...
0.8; 0.9; 1.8; 3.8; 6.1; 2.9;];
y =[9.1; 9.0; 8.9; 9.0; 9.0; 9.0; 9.0; 9.0; 8.2; 5.9; 2.6; 5.9; 7.6; ...
6.8; 5.9; 2.6; 6.0; 2.7; 5.9; 2.6; 6.1; 2.8; 8.9; 8.4; 5.0; 7.6; ...
4.1; 6.8; 3.6; 6.4; 3.5; 5.1; 3.4; 4.4; 6.3; 3.7; 6.1; 3.3; 5.6; ...
8.1; 2.2; 7.4; 1.8; 6.7; 1.1; 1.2; 1.1; 5.6; 4.3; 2.2; 1.1; 1.1; ...
1.2; 4.8; 1.1; 1.1; 1.1; 3.7; 2.8; 1.6; 1.0; 1.2; 1.1; 1.1; 1.0; ...
1.1; 1.0; 2.7; 3.0; 5.5; 4.7; 7.3; 8.4; 8.9; 9.0; 6.3; 6.3; 8.5; ...
5.3; 3.4; 1.1; 1.2; 6.5; 8.8;];
PunktNummer= [ 1; 2; 3; 4; 5; 6; 7; 8; 9;10;11;12;13;14;15;16;17;18; ...
19;20;21;22;23;24;25;26;27;28;29;30;31;32;33;34;35;36;37;38;39; ...
40;41;42;43;44;45;46;47;48;49;50;51;52;53;54;55;56;57;58;59;60; ...
61;62;63;64;65;66;67;68;69;70;71;72;73;74;75;76;77;78;79;80;81; ...
82;83;84;];
PunkteZahl = 84;
HalbePunkteZahl = 42;
es_tsp('ReiseMatrix')
end % Action=ReiseBE
%-------------------- Action = ReiseBenutzer
% Ermoeglicht es dem Benutzer, eine eigene Reiseroute mit
% der Maus festzulegen. Es muessen mindestens 3 Staedte
% definiert werden, wobei ein markieren einer Stadt mit
% der rechten Maustaste die Definition von zusaetzlichen
% Staedten beendet.
if strcmp(Action,'ReiseBenutzer')
fig_Reise=figure;
clf
Seite 139
Kapitel 14: Programm-Texte
title('Linke Maustaste: Punkt, Rechte Maustaste: Letzter Punkt')
axis([0 10 0 10])
grid on
hold on
echo off
x = [];
y = [];
PunkteZahl = 0;
PunktNummer = [];
% Schleife, um die Punkte aufzunehmen
% Mindestens 3 Punkte muessen eingeben werden
% Rechte Maustaste setzt letzten Punkt
but = 1;
while (but == 1)|(PunkteZahl<3)
[xi,yi,but] = ginput(1);
plot(xi,yi,'go','era','back')
PunkteZahl = PunkteZahl + 1;
text(xi,yi,[' ' int2str(PunkteZahl)],'era','back')
x = [x; xi];
y = [y; yi];
PunktNummer= [PunktNummer; PunkteZahl];
end % while but
HalbePunkteZahl=round(PunkteZahl/2);
delete(fig_Reise)
es_tsp('ReiseMatrix')
end % Action=ReiseBenutzer
%-------------------- Action = SetPop / Slider auswerten
% Wird aufgerufen, wenn der Benutzer am Slider "Individuen"
% eine neue Anzahl von Individuen für den Simulationslauf einstellt.
if strcmp(Action,'SetPop')
Individuen = round(get(Population_Slide,'Value'));
set(Population_text,'string',[num2str(Individuen),' Individuen'])
es_tsp('ReiseMatrix')
es_tsp('WegeBerechnen')
BesterWegKurve(GenerationsCntr)=MinWeg;
GenerationsCntr = 1;
end % Action=SetPop
%-------------------- Action = SetMaxGen / Slider auswerten
% Wird aufgerufen, wenn der Benutzer am Slider "Last Generation"
% eine neue Anzahl für die Abbruchbedingung der letzten
% zu simulierenden Generation einstellt. Diese Abbruchbedingung
% wird nur beachtet, wenn am Pop-Up "Stop" die
% Option "When done" eingestellt worden ist.
if strcmp(Action,'SetMaxGen')
MaxGenerations = round(get(Generation_Slide,'Value'));
set(Generation_text,'string',['Last Generation ',num2str(MaxGenerations)])
end % Action=SetMaxGen
%-------------------- Action = SetMoving / Slider auswerten
% Wird aufgerufen, wenn der Benutzer am Slider "Moving"
% eine neue Wahrscheinlichkeit für die Moving-Mutation einstellt.
if strcmp(Action,'SetMoving')
Moving = round(get(Moving_Slide,'Value'));
set(Moving_text,'string',['Moving ',num2str(Moving),' %'])
end % Action=SetMoving
%-------------------- Action = SetExchange / Slider auswerten
% Wird aufgerufen, wenn der Benutzer am Slider "Exchange"
% eine neue Wahrscheinlichkeit für die Exchange-Mutation einstellt.
if strcmp(Action,'SetExchange')
Exchange = round(get(Exchange_Slide,'Value'));
set(Exchange_text,'string', ['Exchange ',num2str(Exchange),' %'])
end % Action=SetExchange
%-------------------- Action = SetInsert / Slider auswerten
% Wird aufgerufen, wenn der Benutzer am Slider "Insert"
% eine neue Wahrscheinlichkeit für die Insert-Mutation einstellt.
if strcmp(Action,'SetInsert')
Insert = round((get(Insert_Slide,'Value')));
set(Insert_text,'String',['Insert ',num2str(Insert),' %'])
end % Action=SetInsert
Seite 140
Kapitel 14: Programm-Texte
%-------------------- Action = SetInversion / Slider auswerten
% Wird aufgerufen, wenn der Benutzer am Slider "Inversion"
% eine neue Wahrscheinlichkeit für die Inversions-Mutation einstellt.
if strcmp(Action,'SetInversion')
Inversion = round(get(Inversion_Slide,'Value'));
set(Inversion_text,'string', ['Inversion ',num2str(Inversion),' %'])
end % Action=SetInversion
%-------------------- Action = Go
% Wird aufgerufen, wenn der Benutzer den "Go"-Button
% betaetigt. Diese Action belegt verschiedene Variablen vor
% und startet über die Action "Loop" die Simulation von Generationen.
if strcmp(Action,'Go')
if MatrixExists == false
es_tsp('ReiseMatrix')
BesterWegKurve = [];
GenerationsCntr = 1;
end % if MatrixExists
Endbedingung = false;
OneStep
= false;
set(Restart_Button,'Visible','on')
Status = 'Selected Option: Go';
es_tsp('Redraw')
es_tsp('Loop')
end % Action=Go
%-------------------- Action = Stop
% Haelt die Simulation von Generationen durch die
% Action "Loop" am Ende eines Generationszyklus an.
if strcmp(Action,'Stop')
Status = 'Selected Option: Stop';
Endbedingung = true;
es_tsp('Redraw')
end % Action=Stop
%------------ Action = WegeBerechnen
% Berechnet die Weglaengen der Reiserouten
% aller zur Zeit vorhandenen Individuen.
if strcmp(Action,'WegeBerechnen')
Wege
= zeros(1,size(Population_Kinder,2));
for cntr = 1:size(Population_Kinder,2),
ActualWeg = 0;
for i=1:(PunkteZahl-1)
%% Pythagoras c^2 = sqrt(a^2+b^2)
ActualWeg = ActualWeg+sqrt(...
(x(Population_Kinder(i+1,cntr))-x(Population_Kinder(i,cntr)))^2 ...
+(y(Population_Kinder(i+1,cntr))-y(Population_Kinder(i,cntr)))^2);
end % for i
Wege(cntr) = ActualWeg;
end % for anzahl
[MinWeg,MinWegIndex] = min(Wege);
end % Action=WegeBerechnen
%-------------------- Action = New
% Setzt das Programm auf die Anfangswert zurueck,
% wobei der Zufallszahlengenerator nicht veraendert wird.
if strcmp(Action,'New')
es_tsp('SetDefaults')
es_tsp('SetReise')
es_tsp('WegeBerechnen')
set(ReiseZiel,'Value',1);
set(CareForClausel,'Value',1);
set(Restart_Button,'Visible','off')
Endbedingung
= true;
RandomMerker
= rand('seed');
BesterWegKurve(GenerationsCntr) = MinWeg;
es_tsp('Redraw')
end % Action=New
%-------------------- Action = Step
% Startet die Simulation von einer Generation und
% stoppt danach wieder.
if strcmp(Action,'Step')
OneStep=true;
Seite 141
Kapitel 14: Programm-Texte
if MatrixExists==false
es_tsp('ReiseMatrix')
set(Restart_Button,'Visible','on')
Population_Kinder=Population_Eltern;
BesterWegKurve = [];
GenerationsCntr = 1
else
Endbedingung=false;
end % if MatrixExists
Status = 'Selected Option: One Step';
es_tsp('Redraw')
es_tsp('Loop')
end % Action=Step
%-------------------- Action = Restart
% Setzt das Programm auf die Anfangswert zurueck,
% wobei der Zufallszahlengenerator auf den Wert,
% den er beim letzten Start hatte, zurueckgesetzt wird.
if strcmp(Action,'Restart')
es_tsp('SetDefaults')
Status = 'Generation Counter reset';
val = get(ReiseZiel,'Value');
%% Bei BenuzterDefinierter Reise nicht
%% aufrufen, sonst wird die letzte vom
%% Benuzter definierte Reise geloescht
if ~(val==4)
es_tsp('SetReise')
else
delete(BesterWegPlot)
BesterWegPlot = subplot(2,2,1);
end % if ~(val==4) ...
es_tsp('ReiseMatrix')
es_tsp('WegeBerechnen')
BesterWegKurve(GenerationsCntr) = MinWeg;
AverageWegKurve(GenerationsCntr) = MinWeg;
rand('seed',RandomMerker)
es_tsp('Redraw')
end % Action=Restart
%-------------------- Action = Loop
% Simuliert die Evolution über mehrere Generationen,
% bis eine Endbedingung eintritt:
% - Benutzer betaetigt "Stop"-Button
% - Anzahl der gewuenschten Generationen wird ueberschritten
% - Fitness des besten Individuums entspricht der durchschnittlichen
%
Fitness aller Individuen
if strcmp(Action,'Loop')
while ((GenerationsCntr<=MaxGenerations)|(CareFor==false)) ...
&(Endbedingung==false)
GenerationsCntr=GenerationsCntr+1;
%% Schrittweiten groesser "1" durch "1" ersetzen
temp=SW>1;
SW=SW.*(~temp)+temp;
%% Um Geschwindigkeit zu gewinnen, wird die Population der Kinder
%% mit dem Befehl zeros auf einmal an angelegt. Dazu muss erst
%% einmal die zu erwartende Groesse der Population berechnet werden ...
TempGenerationOversize= ...
round((Individuen*Exchange) /100) ...
+round((Individuen*Moving)
/100) ...
+round((Individuen*Insert)
/100) ...
+round((Individuen*Inversion)/100);
Population_Kinder= ...
[Population_Eltern ,zeros(PunkteZahl,TempGenerationOversize)];
%% Neu genererierte Individuen (Kinder) werden ab <p_zeiger> in die
%% Eltern-Generation angehaengt
p_zeiger=Individuen+1;
%% Mutation 'Exchange'
%% Austausch von zwei Staedten in der Tour
Seite 142
Kapitel 14: Programm-Texte
%% Einfluss der Schrittweite:
%% Die Schrittweite beeinflusst den Abstand der beiden
%% zu tauschenden Staedte voneinander
if Exchange>0
for i=1:round((Individuen*Exchange)/100)
Tour=round((rand*Individuen)+0.5);
Stadt1=round((rand*PunkteZahl)+0.5);
Stadt2=Stadt1+round((rand*SW(Tour)*(PunkteZahl-Stadt1-1))+0.5);
if Stadt1==Stadt2
if Stadt1>(HalbePunkteZahl) Stadt2=Stadt1-1;
else
Stadt2=Stadt1+1;
end % if Stadt1>(PunkteZahl/2)
end % if Stadt1==Stadt2
Population_Kinder(:,p_zeiger)=Population_Eltern(:,Tour);
Population_Kinder(Stadt1,p_zeiger)=Population_Kinder(Stadt2,p_zeiger);
Population_Kinder(Stadt2,p_zeiger)=Population_Eltern(Stadt1,Tour);
% Jetzt die Schrittweite zufaellig aendern
% SW_Change: 0 oder 1 oder 2
% 0 -> /1.5
1 -> *1.5
2 -> unveraendert
SW_Change=floor(rand*2+0.5);
if
SW_Change==0 SW(p_zeiger)=SW(Tour)/1.5;
elseif SW_Change==1 SW(p_zeiger)=SW(Tour)*1.5;
else
SW(p_zeiger)=SW(Tour);
end;
p_zeiger=p_zeiger+1;
end % for i
end % if Exchange
%% Mutation 'Moving'
%% Ein Tour-Stueck wird an einer zufaelligen Stelle den Genen entnommen
%% und an einer zufaelligen Stelle wieder in die Genen eingefuegt
%% Einfluss der Schrittweite:
%% Die Schrittweite beeinflusst die Anzahl der zu verschiebenden Staedte
if Moving>0
for i=1:round((Individuen*Moving)/100)
Tour = round((rand*Individuen)+0.5);
Anzahl= round(rand*SW(Tour)*(PunkteZahl-1)+0.5);
Stadt = round((rand*(PunkteZahl-Anzahl))+0.5);
Ziel = round((rand*(PunkteZahl-Anzahl))+0.5);
Population_Kinder(:,p_zeiger)= ...
str_del(Population_Eltern(:,Tour),Stadt,Anzahl);
Population_Kinder(:,p_zeiger)=str_in(Population_Kinder(:,p_zeiger), ...
Population_Eltern(Stadt:(Stadt+Anzahl-1),Tour), Ziel);
% Jetzt die Schrittweite zufaellig aendern
% SW_Change: 0 oder 1 oder 2
% 0 -> /1.5
1 -> *1.5
2 -> unveraendert
SW_Change=floor(rand*2+0.5);
if
SW_Change==0 SW(p_zeiger)=SW(Tour)/1.5;
elseif SW_Change==1 SW(p_zeiger)=SW(Tour)*1.5;
else
SW(p_zeiger)=SW(Tour);
end;
p_zeiger=p_zeiger+1;
end % for i
end % if Moving
%% Mutation 'Insert'
%% Eine einzelne Stadt wird den Genen entnommen und an einer
%% zufaelligen Stelle wieder in die Gene eingefuegt
%% Einfluss der Schrittweite:
%% Die Schrittweite bestimmt den maximalen Abstand zwischen
%% der Entnahmestelle und Einfuegestelle der Stadt
if Insert>0
for i=1:round((Individuen*Insert)/100)
Tour = round((rand*Individuen)+0.5);
Stadt= round((rand*(PunkteZahl))+0.5);
Ziel = Stadt+round((rand*SW(Tour)*(PunkteZahl-Stadt-1))+0.5);
if Ziel==Stadt
if Stadt>(HalbePunkteZahl) Ziel=Stadt-1;
else
Ziel=Stadt+1;
end %if Stadt>(PunkteZahl/2)
end %if Ziel==Stadt
Population_Kinder(:,p_zeiger)= ...
str_del(Population_Eltern(:,Tour),Stadt,1);
Population_Kinder(:,p_zeiger)=str_in(Population_Kinder(:,p_zeiger), ...
Seite 143
Kapitel 14: Programm-Texte
Population_Eltern(Stadt,Tour), Ziel);
% Jetzt die Schrittweite zufaellig aendern
% SW_Change: 0 oder 1 oder 2
% 0 -> /1.5
1 -> *1.5
2 -> unveraendert
SW_Change=floor(rand*2+0.5);
if
SW_Change==0 SW(p_zeiger)=SW(Tour)/1.5;
elseif SW_Change==1 SW(p_zeiger)=SW(Tour)*1.5;
else
SW(p_zeiger)=SW(Tour);
end;
p_zeiger=p_zeiger+1;
end % for i
end % if Insert
%% Mutation 'Inversion'
%% Ein Tour-Stueck wird um 180 Grad gedreht.
%% Einfluss der Schrittweite:
%% Die Schrittweite veraendert die Anzahl der Staedte,
%% die der Inversion unterliegen
if Inversion>0
for i=1:round((Individuen*Inversion)/100)
Tour
= round((rand*Individuen)+0.5);
Stadt1 = round((rand*(PunkteZahl-1))+0.5);
Stadt2 = round((rand*SW(Tour)*(PunkteZahl-Stadt1)+0.5)+Stadt1);
Population_Kinder(:,p_zeiger)=Population_Eltern(:,Tour);
Population_Kinder(Stadt1:Stadt2,p_zeiger)= ...
rot90(Population_Eltern(Stadt1:Stadt2,Tour),2);
% Jetzt die Schrittweite zufaellig aendern
% SW_Change: 0 oder 1 oder 2
% 0 -> /1.5
1 -> *1.5
2 -> unveraendert
SW_Change=floor(rand*2+0.5);
if
SW_Change==0 SW(p_zeiger)=SW(Tour)/1.5;
elseif SW_Change==1 SW(p_zeiger)=SW(Tour)*1.5;
else
SW(p_zeiger)=SW(Tour);
end;
p_zeiger = p_zeiger+1;
end % for i
end % if Inversion
es_tsp('WegeBerechnen')
Population_fitness=0;
%%
%%
%%
%%
%%
Selektion:
- Sortieren der Individuen nach Weglaenge
- Uebernahme der besten Individuen in die naechste Generation
- Ermitteln der mittleren Fitness (mittlerer Weg) der neuen Generation
- Schrittweite mit umsortieren
[dummy,index]=sort(Wege);
SW_Temp=SW;
for i=1:Individuen,
Population_Eltern(:,i)=Population_Kinder(:,index(i));
Population_fitness=Population_fitness+Wege(index(i));
SW(i)=SW_Temp(index(i));
end % for i
Population_fitness=Population_fitness/Individuen;
AverageWegKurve(GenerationsCntr)=Population_fitness;
%% Abbruchbedingungen ueberpruefen
if (((Population_fitness-MinWeg)<0.001)&(CareFor==true))
Endbedingung=true;
end % if Population_fitness
BesterWegKurve(GenerationsCntr)=MinWeg;
es_tsp('Redraw')
if OneStep==true Endbedingung=true;
end % if OneStep
end
% while Endbedingung == false
Status=('Waiting for Userinput');
end
% Action=Loop
%-------------------- Action = Info
% Oeffnet ein erstes Fenster mit Erklärungen.
Seite 144
Kapitel 14: Programm-Texte
%% Wurde nicht als das unter MATLAB 4.2 uebliche
%% HTML-File realisiert, da auch unter MATLAB 4.0
%% gearbeitet wurde und diese Feature dort noch
%% nicht verfügbar ist ...
if strcmp(Action,'Info')
if (InfoIsOpen==false)
Info_Window=figure('name','Info Window','NumberTitle','off');
InfoIsOpen=true;
else
figure(Info_Window);
end % if InfoIsOpen==...
clf
infoDone_Button= ...
uicontrol('Style','Pushbutton','Position', [.86 .02 .12 .08], ...
'Units','normalized', ...
'Callback','es_tsp(''InfoDone'')','String','Close');
infoMore_button= ...
uicontrol('Style','Pushbutton','Position', [.70 .02 .12 .08], ...
'Units','normalized', ...
'Callback','es_tsp(''InfoMore'')','String','More');
if CurrentInfoPage==1
figtext(.02,.94,'Travelling Salesman Problem (TSP):')
figtext(.02,.88, ...
'Ein Handlungsreisender soll nacheinander auf einer kostenminimalen')
figtext(.02,.84, ...
'Tour n Staedte besuchen, wobei jede Stadt nur einmal aufgesucht werden')
figtext(.02,.80, ...
'darf. Die Kosten sollen hier durch die Weglaenge der Tour bestimmt')
figtext(.02,.76, ...
'werden. Das TSP soll symmetrisch sein, d.h. die Entfernung zwischen')
figtext(.02,.72,'zwei Staedten ist richtungsunabhaengig.')
figtext(.02,.66,'Die Oberflaeche:')
figtext(.02,.62,'Step-Button:')
figtext(.24,.62,'Berechnung einer Generation starten')
figtext(.02,.58,'Go-Button :')
figtext(.24,.58,'Berechnung starten')
figtext(.02,.54,'Stop-Button:')
figtext(.24,.54,'Berechnung anhalten')
figtext(.02,.50,'Info-Button:')
figtext(.24,.50,'Dieses Fenster oeffnen')
figtext(.02,.46,'Restart-Button:')
figtext(.24,.46,'Zufallsgenerator auf letzten Startwert setzen')
figtext(.24,.42,'und Generationen-Zaehler auf "1" ruecksetzen')
figtext(.02,.38,'New-Button:')
figtext(.24,.38,'Neustart der Simulation')
figtext(.02,.34,'Done-Button:')
figtext(.24,.34,'Beenden der Simulation')
end % if CurrentInfoPage==1
if CurrentInfoPage==2
figtext(.02,.94,'Travelling Salesman Problem (TSP):')
figtext(.02,.88,'Die Schiebeschalter:')
figtext(.02,.84,'Last Generation:')
figtext(.24,.84, ...
'Abbruchbedingung fuer den Generationen-Zaehler festlegen')
figtext(.02,.80,'Individuen:')
figtext(.24,.80,'Anzahl der simulierten Individuen waehlen')
figtext(.02,.72,'Moving:')
figtext(.20,.72,'%-Zahl der der Moving-Mutation unterworfenen Individuen')
figtext(.02,.68,'Exchange:')
figtext(.20,.68, ...
'%-Zahl der der Exchange-Mutation unterworfenen Individuen')
figtext(.02,.64,'Inversion:')
figtext(.20,.64, ...
'%-Zahl der der Inversion-Mutation unterworfenen Individuen')
figtext(.02,.60,'Insert:')
figtext(.20,.60,'%-Zahl der der Insert-Mutation unterworfenen Individuen')
figtext(.02,.54,'Der linke Plot:')
figtext(.02,.50, ...
'Dargestellt wird in Gelb der Verlauf der Entwicklung des Weges ueber der')
figtext(.02,.46, ...
'Generationenzahl. Dafuer wird jeweils die kuerzeste Distanze innerhalb')
figtext(.02,.42, ...
'einer Generation von Individuen ausgewaehlt. In Gruen wird der gemittelte')
figtext(.02,.38,'Weg aller Eltern-Individuen dargestellt.')
Seite 145
Kapitel 14: Programm-Texte
figtext(.02,.32,'Der Rechte Plot:')
figtext(.02,.28, ...
'Dargestellt wird der Weg, den die Gene des innerhalb der aktuellen')
figtext(.02,.24,'Generation besten Individuums beschreiben.')
end % if CurrentInfoPage==2
end % Action=Info
%-------------------- Action = InfoMore
% Schaltet zwischen zwei Fenster mit Erklaerungen um.
if strcmp(Action,'InfoMore')
if
CurrentInfoPage==1 CurrentInfoPage=2;
else
CurrentInfoPage=1;
end % if CurrentInfoPage==1
es_tsp('Info')
end % Action=InfoDone
%-------------------- Action = InfoDone
% Schliesst alle Fenster mit Erklaerungen.
if strcmp(Action,'InfoDone')
if InfoIsOpen==true delete(Info_Window)
end % if InfoIsOpen
InfoIsOpen=false;
end % Action=InfoDone
%-------------------- Action = Done
% Beendet das Programm.
if strcmp(Action,'done')
es_tsp('InfoDone')
delete(MainFigure)
clear all
end % Action=Done
end
% von ES_TSP.M
Seite 146
Kapitel 14: Programm-Texte
14.2.2 STR_IN.M von ES_TSP.M
STR_IN.M fügt Zahlen in einen Zahlenvektor ein.
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
function str_in
Status: ( ) blocked
( ) testing
Last Revision: 22.10.95
(X) ready for use
(c) by Jan-Erik Engels
Funktion: Fuegt ab <index> die Werte <value> in eine
Zeilen-Matrix ein und schneidet die ueberzaehligen Werte ab.
IN:
eine Zeile-Matrix, der Startwert <index>,
der index <ziel> fuer das Einfuegen der Werte
Out: die geaenderte Zeilen-Matrix
abgefangene Fehler:
- Ungleichheit der Vector-Dimensionen
- Cross_over Punkt ausserhalb der Vectoren
function result=str_in(vector,value,ziel)
if ~(ziel>length(vector))
result=vector(1:ziel-1);
result=[result; value];
result=[result; vector(ziel:(length(vector)-length(value)))];
end % if
end % function
Seite 147
Kapitel 14: Programm-Texte
14.2.3 STR_DEL.M von ES_TSP.M
STR_DEL.M entfernt Zahlen aus einem Zahlenvektor.
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
function str_del
Status: ( ) blocked
( ) testing
Last Revision: 22.10.95
(X) ready for use
(c) by Jan-Erik Engels
Funktion: Loescht ab <index> eine <anzahl> von ZeilenMatrix-Werten und fuellt die Zeilen-Matrix
mit „Nullen" auf
IN:
eine Zeile-Matrix, der Startwert <index>,
die <anzahl> zu loeschenden Werte
Out: die geaenderte Zeilen-Matrix
abgefangene Fehler:
- Ungleichheit der Vector-Dimensionen
- Cross_over Punkt ausserhalb der Vectoren
function Result=str_del(vector,index,anzahl)
if ~(index>length(vector))
Result= vector(1:(index-1));
Result= [Result; vector((index+anzahl):length(vector))];
Result= [Result; zeros(anzahl,1)];
end % if ~(index>length(vector))
end
Seite 148
Kapitel 14: Programm-Texte
14.3 Das MATLAB-Programm ES_FUZZY.M
14.3.1 ES_FUZZY.M
ES_FUZZY.M ist ein Programm zur Optimierung von Fuzzy-Systemen für einen vorgegebenen Anwendungsfall.
Die eigentliche Simulation / Optimierung findet im Programmteil mit der Action „Loop" statt.
function ES_FUZZY(Action)
%
%
%
%
%
%
%
%
%
%
%
Funktion ES_FUZZY - Fuzzy mit Evolutionaeren Strategien
Version 1.9
(c) Jan-Erik Engels 1995-96
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 02.01.96
Beschreibung:
% Ueberpruefen, ob Programm ohne Parameter aufgerufen wurde
% -> Benutzeraufruf: Programm starten
if nargin<1
clear all;
Action='Init';
end
% Usefull things
hold off
echo off
pause on
% Globale Variablen-Liste
% Diese Liste ist notwendig, da sich das
% Programm rekursiv selbstaufrufen kann
%% Fenster von ES_FUZZY
global fig_fuzzy
global fig_main
global fig_surf
global fig_fitness
%
%
%
%
%% Boolean Definition
global false
global true
%
%
global restart_button
global actual_fis_matrix
global
global
global
global
global
global
global
global
global
global
global
global
global
global
actual_path
Bester
BesterFitWert
ChromosomenLaenge
DefuzzFaktor
DefuzzTyp
Endbedingung
Fehlerkurve
FehlerkurvePopulation
fig_fit_azimut
fig_surf_azimut
fis_matrix
fis_matrix_best
Fis_Select
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Ruleview-Fenster
Hauptfenster
Fuzzy-Ausgangskennlinienfeld
Fitness-Kennlinienfeld
Restart Button
Aus einem Chromosom erzeugte
Fuzzy-Matrix
Aktueller Pfad zur Quelldatei
Zeiger auf das beste Individuum
Fitnesswert des besten Individuums
eben die
Mutationswahrscheinlichkeit Defuzzifikation
Liste mit zugelassen Defuzzifikationstypen
Abbruchbedingung fuer die Generationsberechnung
Zeiger auf den Plot im Hauptfenster
Daten des Plots im Hauptfenster
Azimutwinkel des Plots im Fitness-Fenster
Azimutwinkel des Plots im Fuzzy-Ausgangs-Fenster
Von der Platte gelesenes Fuzzy-System
Komplette Fuzzy-Matrix des besten Individuums
Nummer der ausgewaehlten Fuzzy-Matrix,
mit 1 -> ES_F1.FIS
2 -> ES_F2.FIS
3 -> ES_F3.FIS
4 -> Benutzerauswahl einer FIS-Matrix
Seite 149
Kapitel 14: Programm-Texte
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
Fit_Eintrag
fit_field
fit_field_best
fitness
Fuellhoehe
FuzzyOut
FuzzyOut_best
GenerationsCntr
In_Block_Zahl
Individuen
KeinEintrag
MatrixExists
MaxFehler
MaxGenerations
MaximumRange
MFStrings
MFTyp
MFTyp_Maske
MinMaxFaktor
MinMaxTyp
Mutations_Slide_Defuzz
Mutations_Slide_MF
Mutations_text_Defuzz
Mutations_text_MF
MutationsCntr
MutationsFaktor
MutationsFaktor_MF
Oeffnung
OneStep
Out_Block_Zahl
p_eltern
p_kinder
p_speicher
pointer
RandomMerker
rv_notready
ShowAllResults
status
StopWhenDone
global Temperatur
global UseElter1
global
global
global
global
global
UseVerteil
XStart
XY_button
XY_button2
Ziel_Wert
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Wo im Gen steht der Fitness-Wert ?
Fitness-Ausgangskennlinienfeld
Fitness-Ausgangskennlinienfeld des Besten
aktueller Fitnesswert
Matrix mit den zu berechnenden Fuellhoehen
Ausgangskennlinienfeld des Fuzzy-Systems
Ausgangskennlinienfeld des besten Fuzzy-Systems
Zaehler der Generationenzahl
Anzahl der MFs im einem Eingangszweig
Anzahl der Chromosomen (-> Fuzzy-Systeme)
Defaultwert fuer die Fitness-Bewertung
Boolean: Sind Chromsomen vorhanden ?
Epsilon-Umgebung um den Zielwert
Abbruchbedingug fuer letzte Generation
Maximaler Ausgangswert des Fuzzy-Systems
Namen der MF-Kurven im Klartext
Hilfsklassenzuordnung der MF-Kurven
Maskierung fuer die MF-Parameter
Mutationswahrscheinlichkeit MinMax-Mutation
Typen der MinMax-Mutation im Klartext
Slider der Defuzzifikations-Mutation
Slider der MF-Mutation
Text zum Slider Defuzzifikations-Mutation
Text zum Slider MF-Mutation
Zaeht die Anzahl der Mutationen
Mutationswahrscheinlichkeit Parametermutation
Mutationswahrscheinlichkeit MF-Mutation
Flaechenmass der maximalen Gefaessoeffnung
Boolean: Nur eine Generation berechnen
Anzahl der MFs im Ausgangszweig
Eltern-Chromosomen
Nachkommen-Chromosomen
Merker fuer die ersten Generation von Eltern
Zeigerlein
Merker des SEED vom RAND-Generators
Hilfsboolean fuer einen sauberen Start
Boolean: Alle Resultate graphisch anzeigen
String: Statusmeldungen im Hauptfenster
Boolean: Sollen Abbruchbedingungen
beachtet werden ?
Matrix mit den zu berechnenden Temperaturen
Boolean: Sollen die Parameter aus der Quelldatei als Elter Nr.1 verwendet werden ?
Boolean: Die Funktion VERTEIL.M benutzen ?
Zielvorgabe (Sollwert) fuer die Energieentnahme
%% Es sind folgende Actions definiert:
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Action:
Erklärung:
----------------------------------------------Init
- Defaultwerte werden gesetzt,
und die 4 Fenster geoeffnet
RandomMatrix- Chromosomen anlegen
Go
- Wird vom Go-Button aufgerufen
und startet die Action Loop
Stop
- Wird vom Stop-Button aufgerufen
und beendet die GenerationenIteration
New
- Wird vom New-Button aufgerufen
und setzt alle Variablen und
Fenster auf Default-Werte
Restart
- Wird vom Restart-Button aufgerufen und startet die Simulation
neu, wobei der Zufallsgenerator
auf seinen letzten Startwert
zurueckgesetzt wird
Step
- Wird vom Step-Button aufgerufen
und startet die Berechnung von
nur einer Generation
Loop
- Startet die Generationenberechnung,
leistet:
Seite 150
Kapitel 14: Programm-Texte
%
%
%
% Done
> Mutationen
> Selektion
> graphische Darstellung
- Beendet das Programm
%% Es folgen die diversen Actions
%---------------- Action = Init
% Defaultwerte werden gesetzt und 4 Fenster geoeffnet
if strcmp(Action,'Init')
% Vorbelegungen
Individuen
MaxGenerations
MaxFehler
MinMaxFaktor
MutationsFaktor
MutationsFaktor_MF
DefuzzFaktor
fitness
GenerationsCntr
Ziel_Wert
Popu_Slide
MutationsCntr
true
false
Endbedingung
OneStep
MatrixExists
status
ChromosomenLaenge
Oeffnung
Fit_Eintrag
KeinEintrag
fig_surf_azimut
fig_fit_azimut
ShowAllResults
UseElter1
UseVerteil
StopWhenDone
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
12;
15;
0;
0.2;
0.2;
0.2;
0.2;
[];
1;
100;
Individuen;
0;
1;
0;
false;
false;
false;
'Waiting for Userinput';
0;
0.09;
1;
-1;
150;
150;
1;
true;
false;
true;
MinMaxTyp
= ['min
'; 'prod '; 'max
'probor'; 'sum
'];
DefuzzTyp
= ['centroid'; 'bisector'; ...
'mom
'; 'lom
'; ...
'som
'];
MFStrings
= ['dsigmf'
zeros(1, 8); ...
'gauss2mf' zeros(1, 6); ...
'psigmf'
zeros(1, 8); ...
'gbellmf' zeros(1, 7); ...
'trimf'
zeros(1, 9); ...
'sigmf'
zeros(1, 9); ...
'smf'
zeros(1,11); ...
'zmf'
zeros(1,11); ...
'gaussmf' zeros(1, 7); ...
'pimf'
zeros(1,10); ...
'trapmf'
zeros(1, 8)];
%%
%%
%%
%%
%%
%%
%%
%%
%%
%%
%%
%%
%%
Typenzuordnung /
Typ 1: Parameter
Mitte des
Typ 2: Parameter
Mitte des
Typ 3: Parameter
Mitte des
Typ 4: Parameter
Mitte des
Typ 5: Parameter
Mitte des
Typ 6: Parameter
Mitte des
'; ...
Maske (-> Anordnung der Parameter)
[A B C D] mit B<D
MF-Plots ist : (B+D)/2
[A B C ] mit A<C und A<>0 und B>0
MF-Plots ist : C
[A B C ] mit A<B<C
MF-Plots ist : B
[A B
] mit A<B
MF-Plots ist : (A+B)/2
[A B
] mit A<B
MF-Plots ist : B
[A B C D] mit A<B<C<D
MF-Plots ist : (B+C)/2
Seite 151
Kapitel 14: Programm-Texte
MFTyp
= [ 1; 1; 1; 2; 3; 4; 4; 4; 5; 6; 6];
MFTyp_Maske
= [ 1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
0
0
1
1; ...
0; ...
0; ...
0; ...
0; ...
1];
% FIS-Matrix
actual_fis_matrix= 'es_f1.fis';
actual_path
= '';
fis_matrix
= readfis([actual_path actual_fis_matrix]);
% Bildschirm-Aufbau
es_cntrl('Start');
% Random Generatoren -> Status merken
RandomMerker=rand('seed');
% Vorbereitungen
es_cntrl('SetZiel')
es_cntrl('Redraw')
return
end % Action=Init
%-------------------- Action = RandomMatrix
% Es wird eine Matrix mit den Dimensionen
% [Anzahl der Individuen, ChromosomenLaenge] erzeugt.
%
% Fuer den Fall, dass sich der Entwickler beim Entwurf der FIS-Matrix
% schon Gedanken zum System gemacht hat, wird die Geometrie des
% Quellfiles als Elter Nr.1 mit in die Menge der Eltern uebernommen.
% (Abhaengig von der Variablen <UseElter1>)
%
% Aufbau eines Chromosoms:
%
% Gen 1: Die spaeter zu ermittelnde Fitness des Chromosoms
% Gen 2: Anzahl der Membership-Function (MF) In-Bloecke im Chromosom
% Gen 3: Anzahl der Membership-Function (MF) Out-Bloecke im Chromosom
% Gen 4: AndMethod -> 1=min 2=prod
% Gen 5: OrMethod ->
3=max 4=probor
% Gen 6: ImpMethod -> 1=min 2=prod
% Gen 7: AggMethod ->
3=max 4=probor 5=sum
% Gen 8: DefuzzMethod -> Index auf eine Liste
% Anzahl der Blocke <ADB> = Gen 2 + Gen 3
% Gen 9 bis Gen 9+<ADB>: Aufzaehlung der Kurventyp
% Dann folgen <ADB> mal
% Gen mit 1.Kurvenkonstante
% Gen mit 2.Kurvenkonstante
% Gen mit 3.Kurvenkonstante
% Gen mit 4.Kurvenkonstante
%
% ChromosomenLaenge somit: 8+(5*ADB)
if strcmp(Action,'RandomMatrix');
%% Anzahl der Input und Output - Bloecke ermitteln
In_Block_Zahl = sum(getfis(fis_matrix,'NumInputMFs'));
Out_Block_Zahl = getfis(fis_matrix,'NumOutputMFs');
ADB
= In_Block_Zahl + Out_Block_Zahl;
%% Verknuefpungen der fis_matrix ermitteln
if getfis(fis_matrix,'AndMethod')== 'min' AndMethod
else
AndMethod
end
if getfis(fis_matrix,'OrMethod') == 'max' OrMethod
else
OrMethod
end
if getfis(fis_matrix,'ImpMethod')== 'min' ImpMethod
else
ImpMethod
end
AGG = getfis(fis_matrix,'AggMethod');
Seite 152
= 1;
= 2;
= 3;
= 4;
= 1;
= 2;
Kapitel 14: Programm-Texte
if
AGG == 'max'
AggMethod = 3;
elseif AGG == 'probor' AggMethod = 4;
else
AggMethod = 5;
end
MaximumRange
= max(max([getfis(fis_matrix,'InRange');
getfis(fis_matrix,'OutRange')]));
ChromosomenLaenge = 8+(5*ADB);
...
%% Parameter der Fuzzy-Matrix ermitteln und die Eltern-Generation anlegen
p_eltern
= abs(randn(Individuen,ChromosomenLaenge)*30);
for j = 1: Individuen,
for i = (9+ADB):4:ChromosomenLaenge,
p_eltern(j,i:i+3) = sort(p_eltern(j,i:i+3));
end % for i
end % for j
%% "Headerinformationen" der einzelnen Gene generieren
p_eltern(:,1)
= ones(Individuen,1)*KeinEintrag;
p_eltern(:,2)
= ones(Individuen,1)*In_Block_Zahl;
p_eltern(:,3)
= ones(Individuen,1)*Out_Block_Zahl;
p_eltern(:,4)
= ones(Individuen,1)*AndMethod;
p_eltern(:,5)
= ones(Individuen,1)*OrMethod;
p_eltern(:,6)
= ones(Individuen,1)*ImpMethod;
p_eltern(:,7)
= ones(Individuen,1)*AggMethod;
p_eltern(:,8)
= ones(Individuen,1)*1;
%% MF-Funktion zufaellig den Individuen zuordnen
p_eltern(:,9:ADB+8) = round(rand(Individuen,ADB)*size(MFStrings,1)+0.5);
%% Sonderfall: Uebernahme der Parameter aus dem fis-file als Elter 1
if UseElter1==true
% Defuzzy Methode dem Elter 1 zuweisen
defuzzTemp = getfis(fis_matrix,'DefuzzMethod');
for i = 1 : size(DefuzzTyp,1)
if findstr(defuzzTemp, DefuzzTyp(1,:))>0 p_eltern(1,8) == i;
end % if findstr
end % for i
% MF Typen dem Elter 1 zuweisen
typesTemp = str2mat(getfis(fis_matrix,'InMFTypes'), ...
getfis(fis_matrix,'OutMFTypes'));
for j=1 : size(typesTemp,1),
for i=1 : size(MFStrings,1),
if findstr(typesTemp(j,:), MFStrings(i,:))>0 p_eltern(1,(8+j))=i;
end % if findstr
end % for i
end % for j
% MF Parameter dem Elter 1 zuweisen
ParameterTemp=[getfis(fis_matrix,'InMFParams') ; ...
getfis(fis_matrix,'OutMFParams')];
pointer=9+ADB;
for i= 1:size(ParameterTemp,1),
p_eltern(1,pointer:pointer+3) = ParameterTemp(i,:);
pointer = pointer + 4;
end % for i
end % if UseElter1==true
p_speicher=p_eltern;
MatrixExists=true;
return
end % Action=RandomMatrix
%-------------------- Action = Go
% wird vom Go-Button aufgerufen und
% ruft wiederum die Action Loop auf
if strcmp(Action,'Go')
if MatrixExists==false
es_fuzzy('RandomMatrix')
p_speicher
= p_eltern;
Fehlerkurve
= [];
FehlerkurvePopulation = [];
GenerationsCntr = 1;
Seite 153
Kapitel 14: Programm-Texte
MutationsCntr
= 0;
end % if MatrixExists
Endbedingung
= false;
OneStep
= false;
set(restart_button,'Visible','on')
status='Selected Option: Go';
es_cntrl('Redraw');
es_fuzzy('Loop')
return
end % Action=Go
%-------------------- Action = Stop
% wird vom Stop-Button aufgerufen und beendet
% die Generationen-Iteration
if strcmp(Action,'Stop')
status
= 'Selected Option: Stop';
Endbedingung = true;
es_cntrl('Redraw')
return
end % Action=Stop
%-------------------- Action = New
% Wird vom New-Button aufgerufen und setzt alle
% Variablen und Fenster auf Defaultwerte zurueck
if strcmp(Action,'New')
status = 'Matrix killed. Waiting for Userinput';
MatrixExists
= false;
GenerationsCntr
= 1;
Fehlerkurve
= [];
FehlerkurvePopulation = [];
MutationsCntr
= 0;
XStart
= 1;
set(restart_button,'Visible','off')
es_cntrl('Redraw')
return
end % Action=New
%-------------------- Action = Restart
% Wird vom Restart-Button aufgerufen und startet die
% Simulation neu, wobei der Zufallsgenerator auf
% seinen letzten Startwert zurueckgesetzt wird
if strcmp(Action,'Restart')
Endbedingung
= true;
Fehlerkurve
= [];
FehlerkurvePopulation = [];
p_eltern
= p_speicher;
GenerationsCntr
= 1;
MutationsCntr
= 0;
XStart
= 1;
rand('seed',RandomMerker);
status = 'Generation Counter reset, waiting for Userinput';
figure(fig_main);
h
= subplot(2,1,1);
delete (h);
subplot(2,1,1);
set(restart_button,'Visible','off');
if get(Fis_Select,'Value')==4
%% Bei User.def. Fis-Matrix
fis_matrix = es_cntrl('SetFis') %% SetFis nicht ausfuehren
else readfis([actual_path actual_fis_matrix]);
figure(fig_fuzzy);
set(fig_fuzzy,'Userdata',fis_matrix);
my_rv('#update');
end % if get(Fis...
es_fuzzy('Redraw')
MatrixExists = false;
return
end % Action=Restart
%-------------------- Action = Step
% wird vom Step-Button aufgerufen und startet die
% Berechnung von nur einer Generation
if strcmp(Action,'Step')
OneStep = true;
if MatrixExists==false
Seite 154
Kapitel 14: Programm-Texte
es_fuzzy('RandomMatrix')
set(restart_button,'Visible','on')
Fehlerkurve
= [];
FehlerkurvePopulation = [];
GenerationsCntr
= 1;
MutationsCntr
= 0;
else
Endbedingung = false;
end % if MatrixExists
status = 'Selected Option: One Step';
es_cntrl('Redraw')
es_fuzzy('Loop')
return
end % Action=Step
%-------------------- Action = Loop
% Startet die Generationenberechnung, leistet
% - Mutationen
% - Selektion
% - graphische Darstellung
if strcmp(Action,'Loop')
Bester = 1;
BesterFitWert = KeinEintrag;
while ((GenerationsCntr<=MaxGenerations) ...
|(StopWhenDone==false)) ...
&(Endbedingung==false),
% Zeiger auf naechsten moeglichen Eintrag fuer
% zusaetzliche Individuen aus Mutationen
pointer=size(p_eltern,1)+1;
% Ziel-Vorgabe bleibt fuer eine Generation gueltig
% (User kann den Ziel-Wert waehrend der Simulation aendern)
Ziel_Wert_der_Generation=Ziel_Wert;
% Mutationen
% 1. Mutation : Parameter mutieren
if MutationsFaktor>0
InOutBloecke
= sum
(p_eltern(1,2:3));
ZahlDerMutationen = round (MutationsFaktor*Individuen);
% Erzeugen der Zufallszahlen auf einen Rutsch
% - Individuen_wahl : Auswahl des zu mutierenden Individuums
% - Gen_wahl
: Welchen der In- oder Out-Bloecke mutieren ?
% - Neuer_wert: Zahl: Neues Value
Individuen_wahl = round(rand(ZahlDerMutationen,1)*Individuen+0.5);
Gen_wahl
= ((round(rand(ZahlDerMutationen,1)* ...
InOutBloecke+0.5)*4)-4)+InOutBloecke+9;
Neuer_wert
= round((rand(ZahlDerMutationen,1)*MaximumRange) ...
-0.5)/(2*InOutBloecke);
% Vergroessern der Eltern-Generation um die Anzahl
% der zu erwartenden Mutationen
p_eltern = [p_eltern; zeros(ZahlDerMutationen, size(p_eltern,2))];
for n=1:ZahlDerMutationen,
p_eltern(pointer,:) = p_eltern(Individuen_wahl(n),:);
welches_MF_Teil
= round(rand*4+0.5)-1;
%wieviele_Gene
= round(rand*(4-welches_MF_Teil)+0.5);
p_eltern(pointer,(Gen_wahl(n)+welches_MF_Teil)) = Neuer_wert(n);
p_eltern(pointer,Gen_wahl(n):Gen_wahl(n)+3) = sort_0( ...
p_eltern(pointer,Gen_wahl(n):Gen_wahl(n)+3));
p_eltern(pointer,1) = KeinEintrag;
pointer=pointer+1;
end % for n=1:...
MutationsCntr=MutationsCntr+ZahlDerMutationen;
end % if MutationsFaktor
% 2. Mutation : MF-Typ mutieren
if MutationsFaktor_MF>0
ZahlDerMutationen=round(MutationsFaktor_MF*Individuen);
% Erzeugen der Zufallszahlen auf einen Rutsch
% - Individuen_wahl: Auswahl des zu mutierenden Individuums
% - MF_wahl
: Welche Membership-Functions soll mutiert werden ?
% - Neuer Typ
: Nummer der neuen MF-Funktion
Individuen_wahl = round(rand(ZahlDerMutationen,1)*Individuen+0.5);
Seite 155
Kapitel 14: Programm-Texte
MF_wahl
= round(rand(ZahlDerMutationen,1)*InOutBloecke+0.5);
NeuerTyp
= round(rand(ZahlDerMutationen,1)*size(MFStrings,1)+0.5);
% Vergroessern der Eltern-Generation um die Anzahl
% der zu erwartenden Mutationen
p_eltern=[p_eltern; zeros(ZahlDerMutationen, size(p_eltern,2))];
for n=1:ZahlDerMutationen
p_eltern(pointer,:) = ...
chg_mfp(p_eltern(Individuen_wahl(n),:),MF_wahl(n),NeuerTyp(n));
p_eltern(pointer,1) = KeinEintrag;
pointer=pointer+1;
end % for n=1:...
MutationsCntr=MutationsCntr+ZahlDerMutationen;
end % if MutationsFaktor_MF
% 3. Mutation : die 4 Verknuepfungsfunktionen der MFs mutieren
if MinMaxFaktor>0
ZahlDerMutationen=round(MinMaxFaktor*Individuen);
% Erzeugen der Zufallszahlen auf einen Rutsch
% - Individuen_wahl: Auswahl des zu mutierenden Individuums
% - Ziel_wahl
: Welche Verknuepfungsfunktionen mutieren ?
Individuen_wahl = round(rand(ZahlDerMutationen,1)*Individuen+0.5);
Ziel_wahl
= round(rand(ZahlDerMutationen,1)*4+0.5)+3;
% Vergroessern der Eltern-Generation um die Anzahl
% der zu erwartenden Mutationen
p_eltern=[p_eltern; zeros(ZahlDerMutationen, size(p_eltern,2))];
for n=1:ZahlDerMutationen,
p_eltern(pointer,:) = p_eltern(Individuen_wahl(n),:);
Actual_Function=p_eltern(pointer,Ziel_wahl(n));
%% And-Methode
%% 1 <=> min 2 <=> prod
if
Ziel_wahl(n) == 4,
if
p_eltern(pointer,4) == 1 ...
p_eltern(pointer,4) = 2;
else p_eltern(pointer,4) = 1;
end;
%% Or-Methode aendern
%% 3 <=> max 4 <=> probor
elseif Ziel_wahl(n) == 5,
if
p_eltern(pointer,5) == 3 ...
p_eltern(pointer,5) = 4;
else p_eltern(pointer,5) = 3;
end;
%% Imp-Methode aendern
%% 1 <=> min 2<=> prod
elseif Ziel_wahl(n) == 5,
if
p_eltern(pointer,5) == 1 ...
p_eltern(pointer,5) = 2;
else p_eltern(pointer,5) = 1;
end;
%% Agg-Methode aendern
%% 3 <=> max 4 <=> probor 5 <=> sum
elseif Ziel_wahl(n) == 7,
p_eltern(pointer,7) = round( rand * 3 + 0.5) + 2;
end % if Ziel_wahl(n)
p_eltern(pointer,Fit_Eintrag) = KeinEintrag;
pointer=pointer+1;
end % for n=1:...
MutationsCntr=MutationsCntr+ZahlDerMutationen;
end % if MinMaxFaktor
% 4. Mutation : Defuzzifikations-Methode mutieren
if DefuzzFaktor>0
ZahlDerMutationen=round(DefuzzFaktor*Individuen);
% Erzeugen der Zufallszahlen auf einen Rutsch
% - Individuen_wahl : Auswahl des zu mutierenden Individuums
% - Defuzz_wahl
: Welche Defuzzifikation soll zugewiesen werden ?
Individuen_wahl = round(rand(ZahlDerMutationen,1)*Individuen+0.5);
Defuzz_wahl
= round(rand(ZahlDerMutationen,1) ...
* size(DefuzzTyp,1)+0.5);
% Vergroessern der Eltern-Generation um die Anzahl
% der zu erwartenden Mutationen
p_eltern = [p_eltern; zeros(ZahlDerMutationen, size(p_eltern,2))];
for n=1:ZahlDerMutationen,
p_eltern(pointer,:) = p_eltern(Individuen_wahl(n),:);
Seite 156
Kapitel 14: Programm-Texte
p_eltern(pointer,8) = Defuzz_wahl(n);
p_eltern(pointer,1) = KeinEintrag;
pointer=pointer+1;
end % for n=1:...
MutationsCntr=MutationsCntr+ZahlDerMutationen;
end % if MutationsFaktor
% Vorbelegungen fuer diese Generation
p_kinder=p_eltern;
% Bewerten der Fitness der Kinder
disp('Bewerten der Fitness')
%% Beschriftung der Achsen festlegen:
xylabel_texte=getfis(fis_matrix,'InLabels');
ylabel_text =getfis(fis_matrix,'OutLabels');
%% Fitness nur berechnen, wenn diese nicht schon bekannt ist
for i=1:size(p_kinder,1)
if (p_kinder(i,Fit_Eintrag) == KeinEintrag)|(ShowAllResults==3),
[p_kinder(i,Fit_Eintrag),FuzzyOut,fit_field, ...
Temperatur,Fuellhoehe,fis_matrix] = ...
es_f_fit(p_kinder(i,:),fis_matrix,Ziel_Wert_der_Generation);
%% Ausgabe von Zwischenergebnissen
if (ShowAllResults>1)
%% Fenster der Fuzzy-Kurven
figure(fig_fuzzy);
set(fig_fuzzy,'Userdata',fis_matrix, ...
'Name',['Rule Viewer for Individuum ',num2str(i)]);
my_rv('#update');
%% Fenster der Fuzzy-Ausgabe-Werte:
figure(fig_surf);
set(fig_surf,'Name', ...
['Fuzzy Output Surface of Individuum ',num2str(i)]);
surf(Temperatur,Fuellhoehe,FuzzyOut);
xlabel(xylabel_texte(1,:));
ylabel(xylabel_texte(2,:));
zlabel(ylabel_text);
view(fig_surf_azimut,30);
%% Fenster der Regelabweichungen
figure(fig_fitness);
surf(Temperatur,Fuellhoehe,fit_field);
xlabel(xylabel_texte(1,:));
ylabel(xylabel_texte(2,:));
zlabel('Relative Fitness');
view(fig_fit_azimut,30);
set(fig_fitness,'name', ...
['Fitness of Individuum ',num2str(i),': ', ...
num2str(p_kinder(i,Fit_Eintrag))])
drawnow;
else
if p_kinder(i,Fit_Eintrag)>BesterFitWert
BesterFitWert = p_kinder(i,Fit_Eintrag);
fis_matrix_best = fis_matrix;
FuzzyOut_best = FuzzyOut;
fit_field_best=fit_field;
end % if
end % if ShowAllResults>1
end % if p_kinder(Fit_Eintrag...
end % for i
% Selektion
disp('Selektion')
[sortFitness,index] = sort(p_kinder(:,Fit_Eintrag));
p_eltern
= zeros(Individuen,size(p_kinder,2));
for i=1:Individuen,
p_eltern(i,:) = p_kinder(index(i),:);
end % for i
FehlerkurvePopulation(GenerationsCntr,:) ...
= mean(p_eltern(:,Fit_Eintrag));
Fehlerkurve(GenerationsCntr,:) ...
= min(p_eltern(:,Fit_Eintrag));
%% Ausgabe des Besten Individuums:
if (ShowAllResults == 1)
%% Fenster der Fuzzy-Kurven
Seite 157
Kapitel 14: Programm-Texte
figure(fig_fuzzy);
set(fig_fuzzy,'Userdata',fis_matrix_best, ...
'Name','Rule Viewer for the best Individuum');
my_rv('#update');
%% Fenster der Fuzzy-Regler-Oberflaeche
figure(fig_surf);
set(fig_surf,'Name','Fuzzy Output Surface of the best Individuum');
surf(Temperatur,Fuellhoehe,FuzzyOut_best);
xlabel(xylabel_texte(1,:));
ylabel(xylabel_texte(2,:));
zlabel(ylabel_text);
view(fig_surf_azimut,30);
%% Fenster der Fehler-Abweichung
figure(fig_fitness);
surf(Temperatur,Fuellhoehe,fit_field_best);
xlabel(xylabel_texte(1,:));
ylabel(xylabel_texte(2,:));
zlabel('Relative Fitness');
view(fig_fit_azimut,30);
set(fig_fitness,'name', ...
['Fitness of the best Individuum: ',num2str(p_eltern(1,Fit_Eintrag))]);
drawnow;
end % if ShowAllResults==1
% Verwaltungs Aktionen
es_cntrl('Redraw')
GenerationsCntr=GenerationsCntr+1;
if OneStep==true Endbedingung=true;
end % if OneStep
% Hat der User den Ziel-wert geaendert, werden
% alle Fitnes-Werte ungueltig !
if ~(Ziel_Wert==Ziel_Wert_der_Generation)
p_eltern(:,Fit_Eintrag)=ones(size(p_eltern,1),1)*KeinEintrag;
end % if ~(Ziel_Wert ...
end
% while GenerationsCntr<=MaxGenerations
status = 'Waiting for Userinput';
es_cntrl('Redraw')
return
end
% Action=Loop
%-------------------- Action = Done
% wird vom Done-Button aufgerufen und
% beendet das Programm
if strcmp(Action,'done')
%delete (fig_fuzzy);
%delete (fig_fitness);
%delete (fig_surf);
%delete (fig_main);
close all;
clear all;
return
end % Action=Done
end
% ES_FUZZY.M
Seite 158
Kapitel 14: Programm-Texte
14.3.2 ES_F_FIT.M von ES_FUZZY.M
ES_F_FIT.M berechnet die relative Fitness-Zahl für ein ausgewähltes Individuum.
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Funktion ES_F_FIT.M
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 02.01.96
(c) by Jan-Erik Engels 1995-96
Beschreibung:
Ermittelt den Fitnesswert eines Chromosoms (Individuums)
Aufgerufen durch:
es_fuzzy.m
function [Fit_Eintrag,FuzzyOut,fit_field,Temperatur,Fuellhoehe,new_fis] = ...
es_f_fit(kind,fis_matrix,Ziel_Wert);
global Oeffnung
global MaximumRange
%% Aus dem Gen die Fuzzy-Matrix bilden ...
[new_fis,kind]=evalmfp(fis_matrix,kind);
%% Ausgabe-Feld des Fuzzy-Regler generieren
[Temperatur,Fuellhoehe,FuzzyOut]=gensurf(new_fis);
%% Die Abweichung zwischen Soll und Ist berechnen
%% und im <fit_field> ablegen
fit_field= q_calc(FuzzyOut/1000,Temperatur,Fuellhoehe) ...
- Ziel_Wert;
%% die Fitness des aktuellen Individuums berechnen und merken
% Forderungen:
% - kleine Summe der Fehler-Quadrate
% - flacher Verlauf der Fehler-Werte
% - moeglichst Verlauf der Fehler-Wert um "Null"
% -> Bevorzugung von Genen mit Nulluebergang
MIN
= min(fit_field(:));
MAX
= max(fit_field(:));
Fit_Eintrag = sum(sum(fit_field.*fit_field)) ...
*(std(fit_field(:))) ...
*abs(MAX-MIN);
%if sign(MIN)==sign(MAX) Fit_Eintrag = Fit_Eintrag*1.5;
end % if sign(MIN ...
end % function es_f_fit
Seite 159
Kapitel 14: Programm-Texte
14.3.3 VERTEIL.M von ES_FUZZY.M
VERTEIL.M sorgt für eine gleichmäßige Verteilung der Schwerpunkte von MFs innerhalb
einer Spalte von MFs. Dies kann das Konvergenzverhalten bei der Optimierung verbessern.
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Funktion verteil.m
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 02.01.96
IN:
result
- Das unveraenderte Chromosom
MFTypen_Liste - Liste der vorhandenen MFs
Range
- Maximaler Rangewert
Out: result
- Chromosom mit MFs, deren
Mittelpunkte gleichmaessig verteilt sind
(c) by Jan-Erik Engels 1995-96
Beschreibung:
Verteilt die Mittelpunkte der MF-Kurven einer Spalte (Eingang oder
Ausgang) gleichmaessig ueber den Vorgabe-Bereich (Range).
Dazu wird mit dem Wissen ueber den Typ der MF-Funktion deren
Mittelpunkt verschoben.
Funktion wird aufgerufen durch:
evalmfp.m
function result = verteil (result , MFTypen_Liste, Range);
global MFTyp
global true
global MFTyp_Maske
% Hilfsklassenzuordnung der MF-Kurven
% Boolean
% Maskierung fuer MF-Parameter
Offset= Range/size(result,1);
Mitte = Offset/2;
%% mit der Information ueber die derzeitige Mitte
%% wird mit der Variablen <Shift> der Mittelpunkt
%% der MF verschoben ...
for n = 1: size(result,1)
CurrentType=MFTyp(MFTypen_Liste(n));
if
CurrentType == 1
Shift
= Mitte - ((result(n,2) + result(n,4)) / 2);
result(n,2) = result(n,2) + Shift;
result(n,4) = result(n,4) + Shift;
elseif CurrentType == 2
Shift
= Mitte - result (n,3);
result(n,:) = result (n,:) + Shift;
elseif CurrentType == 3
Shift
= Mitte - result (n,2);
result(n,:) = result (n,:) + Shift;
elseif CurrentType == 4
Shift
= Mitte - ((result (n,1) + result (n,2)) / 2);
result(n,1:2) = result (n,1:2) + Shift;
elseif CurrentType == 5
Shift
= Mitte - result (n,2);
result(n,1:2) = result (n,1:2) + Shift;
elseif CurrentType == 6
Shift
= Mitte - ((result (n,2) + result (n,3)) / 2);
result(n,:) = result (n,:) + Shift;
end % if CurrentType
%% und jetzt werden Stellen, die nur Nullen
%% enthalten duerfen ausmaskiert ...
CurrentType
size(n,result)
Seite 160
Kapitel 14: Programm-Texte
size(MFTyp_Maske(CurrentType,:))
result(n,:)=result(n,:).*MFTyp_Maske(CurrentType,:);
Mitte = Mitte + Offset;
end % for n
end % function result
Seite 161
Kapitel 14: Programm-Texte
14.3.4 ES_CNTRL.M von ES_FUZZY.M
In ES_CNTRL.M sind alle Bedienelemente codiert, die ES_FUZZY.M dem Benutzer zur
Verfügung stellt.
function ES_CNTRL(Action)
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Slider, Buttons und Popups von
ES_FUZZY - Fuzzy mit Evolutionaeren Strategien
Version 1.4
(c) Jan-Erik Engels 1995-96
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 23.11.95
Aufgerufen durch:
es_fuzzy.m
Beschreibung: ES_CNTRL enthaehlt alle Actions, die
Button und Slider bedienen und alle
Actions, die fuer einen Fensteraufbau
benoetigt werden
% Globale Variablen-Liste
%% Fenster
global fig_fuzzy
global fig_main
global fig_surf
global fig_fitness
%
%
%
%
Ruleview-Fenster
Hauptfenster
Fuzzy-Ausgangskennlinienfeld
Fitness-Kennlinienfeld
%% Slider und zugehoerige Texte
global Fehler_Slide
global Fehler_text
global Generation_Slide
global Generation_text
global MinMax_Slide
global MinMax_text
global Mutations_Slide_Parameter
global Mutations_text_Parameter
global Mutations_Slide_Defuzz
global Mutations_text_Defuzz
global Mutations_Slide_MF
global Mutations_text_MF
global Popu_Slide
global Popu_text
global Ziel_Slide
global Ziel_Text
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Epsilonumgebung um Zielwert
max. Anzahl der Generationen
Wahrscheinlichkeit MinMax-Mutation
Wahrscheinlichkeit Parameter-Mutation
Wahrscheinlichkeit Defuzzifikations-Mutation
Wahrscheinlichkeit MF-Mutation
Anzahl der Individuen
Sollwertvorgabe fuer Energieentnahme
%% Pop-Ups und zugehoerige Texte
global Done_Select
% Sollen Abbruchbedingungen beachtet werden ?
global Done_Text
%
global Fis_Select
% Auswahl eines Fuzzy-Systems fuer Optimierung
global Fis_Text
%
global Show_Select
% Was soll angezeigt werden ?
global Show_Text
%
global UseElter1_Select
% Sollen die Parameter aus der Quelldatei als
% Elter Nr. 1 benutzt werden ?
global UseElter1_Text
%
global UseVerteil_Select
% Soll die Funktion VERTEIL Anwendung finden ?
global UseVerteil_Text
%
%% Buttons
global done_button
global go_button
global new_button
global RotLeft_button
global RotRight_button
global RotLeft_button2
%
%
%
%
%
%
Done
Go
New
Rotiere Plot Fuzzy-Ausgang links
Rotiere Plot Fuzzy-Ausgang rechts
Rotiere Plot Fitness links
Seite 162
Kapitel 14: Programm-Texte
global
global
global
global
global
global
global
RotRight_button2
step_button
stop_button
restart_button
info_button
XY_button
XY_button2
%
%
%
%
%
%
%
Rotiere Plot Fitness rechts
Step
Stop
Restart
Info
Zeige Fuzzy-Ausgang von oben
Zeige Fitness-Kennlinie von oben
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Aus einem Chromosom erzeugte
Fuzzy-Matrix
Akuteller Pfad zur Quelldatei
Mutationswahrscheinlichkeit Defuzzifikation
Abbruchbedingung fuer Generationenberechnung
Zeiger auf Plot im Hauptfenster
Daten des Plots im Hauptfenster
Azimut des Plots im Fitness-Fenster
Azimut des Plots im Fuzzy-Fenster
Von der Platte gelesenes Fuzzy-System
Komplette Fuzzy-Matrix des besten Individuums
aktueller Fitnesswert
Zaehler der Generationenzahl
Anzahl der Chromosomen (-> Individuen)
Defaultwert fuer die Fitnessbewertung
Boolean: Sind Chromosomen vorhanden ?
Epsilon-Umgebung des Zielwertes
Abbruchbedingung fuer letzte Generation
Maximaler Ausgabewert des Fuzzy-Systems
Namen der MF-Kurven im Klartext
Hilfsklassenzuordnung der MF-Kurven
Maskierung fuer die MF-Parameter
Mutationswahrscheinlichkeit MinMax-Mutation
Type der MinMax-Mutation im Klartext
Zaehlt die Anzahl der Mutationen
Mutationswahrscheinlichkeit
der Parameter-Mutation
Mutationswahrscheinlichkeit der MF-Mutation
Eltern-Chromosomen
Nachkommen-Chromosomen
Merker fuer die erste Generation von Eltern
Hilfsboolean fuer einen sauberen Start
Boolean: Alle Resultate graphisch anzeigen
String: Statusmeldungen im Hauptfenster
Boolean: Sollen Abbruchbedingungen
beachtet werden ?
Matrix der zu berechnenden Temperaturen
Boolean: Sollen die Parameter aus der
Quelldatei verwendet werden ?
Boolean: Die Funktion VERTEIL.M benuzten ?
%% Boolean Definition
global false
global true
global actual_fis_matrix
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
global
actual_path
DefuzzFaktor
Endbedingung
Fehlerkurve
FehlerkurvePopulation
fig_fit_azimut
fig_surf_azimut
fis_matrix
fis_matrix_best
fitness
GenerationsCntr
Individuen
KeinEintrag
MatrixExists
MaxFehler
MaxGenerations
MaximumRange
MFStrings
MFTyp
MFTyp_Maske
MinMaxFaktor
MinMaxTyp
MutationsCntr
MutationsFaktor
global
global
global
global
global
global
global
global
MutationsFaktor_MF
p_eltern
p_kinder
p_speicher
rv_notready
ShowAllResults
status
StopWhenDone
global Temperatur
global UseElter1
global UseVerteil
global XStart
global Ziel_Wert
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Sollwert fuer die Energieentnahme
Action
Beschreibung
---------------------------------------------Start
: Fenster oeffnen und Bedienelemente anlegen
Redraw
: Plot im Hauptfenster aktualisieren
XStartReset
: Plot im Hauptfenster ab 1. Generation anzeigen
XStartP
: Startpunkt des Hauptfensterplots zu hoeheren
Generationenzahlen hin verschieben
XStartM
: Startpunkt des Hauptfensterplots zu kleineren
Generationenzahlen hin verschieben
XYview_fitSurf
: Das Fuzzy-Fenster von oben zeichnen
RotLeft_figSurf
: Das Fuzzy-Fenster um 90 Grad nach links drehen
RotRight_figSurf
: Das Fuzzy-Fenster um 90 Grad nach rechts drehen
RotLeft_figFit
: Das Fitness-Fenster um 90 Grad nach links drehen
XYview_figFit
: Das Fitness-Fenster von oben zeichnen
RotRight_figFit
: Das Fitness-Fenster um 90 Grad nach rechts drehen
SetPop
: Slider der Individuenzahl bedienen
SetFis
: Pop-Up der Quellfile-Auswahl bedienen
Set_StopWhenDone
: Pop-Up der Abbruchbedingung bedienen
Set_UseElter1
: Pop-Up: Sollen Daten des Quellfiles als
Seite 163
Kapitel 14: Programm-Texte
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Elter Nr.1 in die Simulation eingehen ?
Pop-Up: Soll die Funktion VERTEIL.M Anwendung finden ?
Pop-Up: Welche Ergebnisse anzeigen ?
Slider der letzten Generation bedienen
Slider fuer die Fehlerabweichung bedienen
Slider fuer die Sollwertvorgabe bedienen
Slider Mutationswahrscheinlichkeit
fuer MinMax-Mutation bedienen
SetMutation_of_Value : Slider Mutationswahrscheinlichkeit
fuer Parameter-Mutation bedienen
SetMutation_of_MF
: Slider Mutationswahrscheinlichkeit
fuer MF-Kurven-Mutation bedienen
SetMutation_of_Defuzz : Slider Mutationswahrscheinlichkeit
fuer Defuzzifikations-Mutation bedienen
Set_UseVerteil
SetWhatToShow
SetMaxGen
SetFehler
SetZiel
SetMinMaxFaktor
:
:
:
:
:
:
%% Es folgen die diversen Actions
%---------------- Action = Start
if strcmp(Action,'Start')
% figure main
close all;
XStart
= 1;
fig_main = figure('Position',[110 570 560 420], ...
'name','Genetic Fuzzy Controller',...
'NumberTitle','off');
% Buttons of main
step_button=uicontrol('Style','Pushbutton','Position', ...
[.02 .02 .12 .08],'Units','normalized', ...
'Callback','es_fuzzy(''Step'')','String','Step');
go_button=uicontrol('Style','Pushbutton','Position', ...
[.15 .02 .12 .08],'Units','normalized','interruptible','yes', ...
'Callback','es_fuzzy(''Go'')','String','Go','Visible','on');
stop_button=uicontrol('Style','Pushbutton','Position', ...
[.28 .02 .12 .08],'Units','normalized', ...
'Callback','es_fuzzy(''Stop'')','String','Stop');
info_button=uicontrol('Style','Pushbutton','Position', ...
[.43 .02 .12 .08],'Units','normalized', ...
'Callback','hthelp(''es_fuzzy.htm'')','String','Info');
restart_button=uicontrol('Style','Pushbutton','Position', ...
[.58 .02 .12 .08],'Units','normalized','interruptible','yes', ...
'Callback','es_fuzzy(''Restart'')','String','Restart','Visible','off');
new_button=uicontrol('Style','Pushbutton','Position', ...
[.71 .02 .12 .08],'Units','normalized', ...
'Callback','es_fuzzy(''New'')','String','New');
done_button=uicontrol('Style','Pushbutton','Position', ...
[.84 .02 .12 .08],'Units','normalized', ...
'Callback','es_fuzzy(''done'')','String','Done');
XStartP_Reset=uicontrol('Style','Pushbutton','Position', ...
[.02 .97 .04 .04],'Units','normalized', ...
'Callback','es_cntrl(''XStartReset'')','String','1');
XStartP_button=uicontrol('Style','Pushbutton','Position', ...
[.14 .98 .04 .02],'Units','normalized', ...
'Callback','es_cntrl(''XStartP'')','String','->');
XStartM_button=uicontrol('Style','Pushbutton','Position', ...
[.08 .98 .04 .02],'Units','normalized', ...
'Callback','es_cntrl(''XStartM'')','String','<-');
% Sliders of main
Generation_Slide= ...
uicontrol('Style','slider','Position',[.02 .43 .28 .03],...
'Units','normal','Value',MaxGenerations,'Max',500, ...
'Min',10,'Callback','es_cntrl(''SetMaxGen'')');
Generation_text = ...
uicontrol('style','text','units','normal','pos',[.02 .46 .28 .04], ...
'string',['Last Generation ',num2str(MaxGenerations)], ...
'fore','white','HorizontalAlignment','left');
Popu_Slide= ...
uicontrol('Style','slider','Position',[.02 .35 .28 .03],...
'Units','normal','Value',Individuen,'Max',100,'Min',8,...
'Callback','es_cntrl(''SetPop'')');
Popu_text = ...
Seite 164
Kapitel 14: Programm-Texte
uicontrol('style','text','units','normal','pos',[.02 .38 .28 .04], ...
'string',[num2str(Individuen),' Indiviuden'],'fore','white', ...
'HorizontalAlignment','left');
Fehler_Slide= ...
uicontrol('Style','slider','Position',[.02 .27 .28 .03],...
'Units','normal','Value',MaxFehler,'Max',50,'Min',0,...
'Callback','es_cntrl(''SetFehler'')');
Fehler_text = ...
uicontrol('style','text','units','normal','pos',[.02 .30 .28 .04], ...
'string',['Fehler Ziel: ',num2str(MaxFehler),' J'], ...
'fore','white', 'HorizontalAlignment','left');
Ziel_Slide = ...
uicontrol('Style','slider','Position',[.02 .19 .28 .03],...
'Units','normal','Value',Ziel_Wert,'Max',300,'Min',50,...
'Callback','es_cntrl(''SetZiel'')');
Ziel_Text = ...
uicontrol('style','text','units','normal','pos',[.02 .22 .28 .04], ...
'string',['Ziel ',num2str(Ziel_Wert),' J'],'fore','white', ...
'HorizontalAlignment','left');
MinMax_Slide= ...
uicontrol('Style','slider','Position',[.32 .43 .28 .03],...
'Units','normal','Value',MinMaxFaktor,'Max',1,'Min',0,...
'Callback','es_cntrl(''SetMinMaxFaktor'')');
MinMax_text = ...
uicontrol('style','text','units','normal','pos',[.32 .46 .28 .04], ...
'string',['MinMax Mutation ',num2str(MinMaxFaktor*100),'%'], ...
'fore','white', 'HorizontalAlignment','left');
Mutations_Slide_Parameter= ...
uicontrol('Style','slider','Position',[.32 .35 .28 .03],...
'Units','normal','Value',MutationsFaktor,'Max',1,'Min',0,...
'Callback','es_cntrl(''SetMutation_of_Value'')');
Mutations_text_Parameter = ...
uicontrol('style','text','units','normal','pos',[.32 .38 .28 .04], ...
'string',['Value Mutation ',num2str(MutationsFaktor*100),'%'], ...
'fore','white','HorizontalAlignment','left');
Mutations_Slide_MF= ...
uicontrol('Style','slider','Position',[.32 .27 .28 .03],...
'Units','normal','Value',MutationsFaktor_MF,'Max',1,'Min',0,...
'Callback','es_cntrl(''SetMutation_of_MF'')');
Mutations_text_MF = ...
uicontrol('style','text','units','normal','pos',[.32 .30 .28 .04], ...
'string',['MF Mutation ',num2str(MutationsFaktor_MF*100),'%'], ...
'fore','white', 'HorizontalAlignment','left');
Mutations_Slide_Defuzz= ...
uicontrol('Style','slider','Position',[.32 .19 .28 .03],...
'Units','normal','Value',DefuzzFaktor,'Max',1,'Min',0,...
'Callback','es_cntrl(''SetMutation_of_Defuzz'')');
Mutations_text_Defuzz = ...
uicontrol('style','text','units','normal','pos',[.32 .22 .28 .04], ...
'string',['Defuzz Mutation ',num2str(DefuzzFaktor*100),'%'], ...
'fore','white', 'HorizontalAlignment','left');
% Pop-Ups of main
Fis_Select=uicontrol ...
('Style','Popup','String','FIS 1|FIS 2|FIS 3|User def', ...
'Position',[.62 .41 .18 .06],'Units','normalized',...
'CallBack','es_cntrl(''SetFis'')');
Fis_Text = ...
uicontrol('style','text','units','normal','pos',[.62 .46 .18 .04], ...
'string','Fuzzy-System','fore','white', ...
'HorizontalAlignment','left');
Show_Select=uicontrol ...
('Style','Popup','String','best|children|all', ...
'Position',[.62 .31 .18 .06],'Units','normalized',...
'CallBack','es_cntrl(''SetWhatToShow'')');
Show_Text = ...
uicontrol('style','text','units','normal','pos',[.62 .36 .18 .04], ...
'string','Show:','fore','white', ...
'HorizontalAlignment','left');
Done_Select=uicontrol ...
('Style','Popup','String','When done|never', ...
Seite 165
Kapitel 14: Programm-Texte
'Position',[.81 .41 .18 .06],'Units','normalized',...
'CallBack','es_cntrl(''Set_StopWhenDone'')');
Done_Text = ...
uicontrol('style','text','units','normal','pos',[.81 .46 .18 .04], ...
'string','Stop:','fore','white', ...
'HorizontalAlignment','left');
UseElter1_Select =uicontrol ...
('Style','Popup','String','yes|no', ...
'Position',[.81 .31 .18 .06],'Units','normalized',...
'CallBack','es_cntrl(''Set_UseElter1'')');
UseElter1_Text = ...
uicontrol('style','text','units','normal','pos',[.81 .36 .18 .04], ...
'string','Use Source:','fore','white', ...
'HorizontalAlignment','left');
UseVerteil_Select =uicontrol ...
('Style','Popup','String','no|yes', ...
'Position',[.81 .21 .18 .06],'Units','normalized',...
'CallBack','es_cntrl(''Set_UseVerteil'')');
UseVerteil_Text = ...
uicontrol('style','text','units','normal','pos',[.81 .26 .18 .04], ...
'string','Use Verteil:','fore','white', ...
'HorizontalAlignment','left');
fig_surf=figure('Position',[700 570 560 420], ...
'name','Fuzzy Output Surface','NumberTitle','off');
% Buttons of fig_surf
RotLeft_button=uicontrol ...
('Style','Pushbutton', ...
'Position',[.02 .90 .15 .08],'Units','normalized', ...
'Callback', 'es_cntrl(''RotLeft_figSurf'')','String','Rotate Left');
RotRight_button=uicontrol ...
('Style','Pushbutton', ...
'Position',[.83 .90 .15 .08],'Units','normalized', ...
'Callback','es_cntrl(''RotRight_figSurf'')','String','Rotate Right');
XY_button=uicontrol ...
('Style','Pushbutton', ...
'Position',[.41 .90 .15 .08],'Units','normalized', ...
'Callback','es_cntrl(''XYview_figSurf'')','String','XY view');
fig_fitness=figure('Position',[700 100 560 420], ...
'name','Fitness (actual Gen)','NumberTitle','off');
% Buttons of fig_fitness
RotLeft_button2=uicontrol ...
('Style','Pushbutton', ...
'Position',[.02 .90 .15 .08],'Units','normalized', ...
'Callback', 'es_cntrl(''RotLeft_figFit'')','String','Rotate Left');
RotRight_button2=uicontrol ...
('Style','Pushbutton', ...
'Position',[.83 .90 .15 .08],'Units','normalized', ...
'Callback','es_cntrl(''RotRight_figFit'')','String','Rotate Right');
XY_button2=uicontrol ...
('Style','Pushbutton', ...
'Position',[.41 .90 .15 .08],'Units','normalized', ...
'Callback','es_cntrl(''XYview_figFit'')','String','XY view');
rv_notready=true;
fig_fuzzy=my_rv([actual_path actual_fis_matrix]);
while rv_notready
end;
set(fig_fuzzy,'name','Rules of actual Gen','NumberTitle','off');
return
end % Action=Start
%-------------------- Action = Redraw
if strcmp(Action,'Redraw'),
figure(fig_main)
h=subplot(2,1,1);
delete(h);
subplot(2,1,1);
hold on
Seite 166
Kapitel 14: Programm-Texte
title(status)
if length(FehlerkurvePopulation)~=0,
x=[XStart:1:length(FehlerkurvePopulation)];
plot(x, Fehlerkurve(XStart:length(Fehlerkurve)), 'b');
plot(x, FehlerkurvePopulation(XStart:length(FehlerkurvePopulation)),'g');
xlabel(['Epoche: ', num2str(GenerationsCntr), ...
' Mutationen: ',num2str(MutationsCntr), ...
' fit.Population: ', ...
num2str(round(min(FehlerkurvePopulation)))]);
ylabel(['Fehler ',num2str(round(min(Fehlerkurve))),' J'])
end %if length (Fehler...
hold off
drawnow
return
end % Action=Redraw
%-------------------- Action = XStartReset
if strcmp(Action,'XStartReset')
h=gcf;
figure(fig_main);
XStart=1;
es_cntrl('Redraw');
figure(h);
return
end % Action=XStartReset
%-------------------- Action = XStartP
if strcmp(Action,'XStartP')
h=gcf;
figure(fig_main);
XStart=XStart+floor(GenerationsCntr/10)+1;
if XStart>GenerationsCntr
XStart=GenerationsCntr-1;
end % if XStart>
if XStart<1
XStart=1;
end; % if XStart<1
es_cntrl('Redraw');
figure(h);
return
end % Action=XStartP
%-------------------- Action = XStartM
if strcmp(Action,'XStartM')
h=gcf;
figure(fig_main);
XStart=XStart-floor(GenerationsCntr/10)-1;
if XStart<1
XStart=1;
end; % if XStart<1
es_cntrl('Redraw');
figure(h);
return
end % Action=XStartM
%-------------------- Action = XYview_figSurf
if strcmp(Action,'XYview_figSurf')
h=gcf;
figure(fig_surf);
view(fig_surf_azimut,90);
drawnow;
figure(h);
return
end % Action=XYview_figSurf
%-------------------- Action = RotLeft_figSurf
if strcmp(Action,'RotLeft_figSurf')
fig_surf_azimut=fig_surf_azimut-90;
if fig_surf_azimut<0 fig_surf_azimut=fig_surf_azimut+360;
end % if fig_surf
%if (Endbedingung==true)
h=gcf;
figure(fig_surf);
view(fig_surf_azimut,30);
Seite 167
Kapitel 14: Programm-Texte
drawnow;
figure(h);
%end % if (Endbedingung ...
return
end % Action=RotLeft_figSurf
%-------------------- Action = RotRight_figSurf
if strcmp(Action,'RotRight_figSurf')
fig_surf_azimut=fig_surf_azimut+90;
if fig_surf_azimut>360 fig_surf_azimut=fig_surf_azimut-360;
end % if fig_surf
%if (Endbedingung==true)
h=gcf;
figure(fig_surf);
view(fig_surf_azimut,30);
drawnow;
figure(h);
%end % if (Endbedingung ...
return
end % Action=RotRight_figSurf
%-------------------- Action = RotLeft_figFit
if strcmp(Action,'RotLeft_figFit')
fig_fit_azimut=fig_fit_azimut-90;
if fig_fit_azimut<0 fig_fit_azimut=fig_fit_azimut+360;
end % if fig_fit
%if (Endbedingung==true)
h=gcf;
figure(fig_fitness);
view(fig_fit_azimut,30);
drawnow;
figure(h);
%end % if (Endbedingung ...
return
end % Action=RotLeft_figSurf
%-------------------- Action = XYview_figFit
if strcmp(Action,'XYview_figFit')
h=gcf;
figure(fig_fitness);
view(fig_fit_azimut,90);
drawnow;
figure(h);
return
end % Action=XYview_figFit
%-------------------- Action = RotRight_figFit
if strcmp(Action,'RotRight_figFit')
fig_fit_azimut=fig_fit_azimut+90;
if fig_fit_azimut>360 fig_fit_azimut=fig_fit_azimut-360;
end % if fig_fit
%if (Endbedingung==true)
h=gcf;
figure(fig_fitness);
view(fig_fit_azimut,30);
drawnow;
figure(h);
%end % if (Endbedingung ...
return
end % Action=RotRight_figFit
%-------------------- Action = SetPop
if strcmp(Action,'SetPop')
status
= 'Waiting for Userinput';
Individuen
= round(get(Popu_Slide,'Value'));
MatrixExists
= false;
GenerationsCntr = 1;
Fehlerkurve
= [];
FehlerkurvePopulation = [];
p_eltern
= [];
p_kinder
= [];
p_speicher
= [];
fitness
= [];
MutationsCntr
= 0;
Seite 168
Kapitel 14: Programm-Texte
Endbedingung
= true;
set(restart_button,'Visible','off');
set(Popu_text,'string',[num2str(Individuen),' Individuen']);
return
end % Action=SetPop
%-------------------- Action = SetFis
if strcmp(Action,'SetFis')
val=get(Fis_Select,'Value');
if
(val == 1),
actual_fis_matrix = 'es_f1.fis';
actual_path
= '';
fis_matrix
= readfis([actual_path actual_fis_matrix]);
MatrixExists = false;
elseif (val == 2),
actual_fis_matrix = 'es_f2.fis';
actual_path
= '';
fis_matrix
= readfis([actual_path actual_fis_matrix]);
MatrixExists = false;
elseif (val == 3),
actual_fis_matrix = 'es_f3.fis';
actual_path
= '';
fis_matrix
= readfis([actual_path actual_fis_matrix]);
MatrixExists = false;
elseif (val == 4),
[f,p]=uigetfile('*.fis');
if exist([p f])>0
actual_fis_matrix = f;
actual_path
= p;
fis_matrix
= readfis([actual_path actual_fis_matrix]);
end % if exist
figure(fig_fuzzy);
set(fig_fuzzy,'Userdata',fis_matrix);
my_rv('#update');
MatrixExists = false;
end;
figure(fig_fuzzy);
set(fig_fuzzy,'Userdata',fis_matrix);
my_rv('#update');
MatrixExists=false;
end % Action=SetFis
%-------------------- Action = Set_StopWhenDone
if strcmp(Action,'Set_StopWhenDone')
val=get(Done_Select,'Value');
if
(val == 1), StopWhenDone = true;
elseif (val == 2), StopWhenDone = false;
end;
end % Action=Set_StopWhenDone
%-------------------- Action = Set_UseElter1
if strcmp(Action,'Set_UseElter1')
val=get(UseElter1_Select,'Value');
if
(val == 1), UseElter1 = true;
elseif (val == 2), UseElter1 = false;
end;
end % Action=Set_UseElter1
%-------------------- Action = Set_UseVerteil
if strcmp(Action,'Set_UseVerteil')
val=get(UseVerteil_Select,'Value');
if
(val == 1), UseVerteil = false;
elseif (val == 2), UseVerteil = true;
end;
end % Action=Set_UseVerteil
%-------------------- Action = SetWhatToShow
if strcmp(Action,'SetWhatToShow')
val=get(Show_Select,'Value');
if
(val == 1), ShowAllResults=1; % Show Best
elseif (val == 2), ShowAllResults=2; % Show Children
elseif (val == 3), ShowAllResults=3; % Show all
end;
end % Action=SetWhatToShow
Seite 169
Kapitel 14: Programm-Texte
%-------------------- Action = SetMaxGen
if strcmp(Action,'SetMaxGen')
status
= 'Waiting for Userinput';
MaxGenerations = round(get(Generation_Slide,'Value'));
set(Generation_text,'string',['Last Generation ',num2str(MaxGenerations)])
return
end % Action=SetMaxGen
%-------------------- Action = SetFehler
if strcmp(Action,'SetFehler')
status
= 'Waiting for Userinput';
MaxFehler = round(get(Fehler_Slide,'Value'));
set(Fehler_text,'string',['Fehler Ziel: ',num2str(MaxFehler),' J'])
return
end % Action=SetFehler
%-------------------- Action = SetZiel
if strcmp(Action,'SetZiel')
status
= 'Waiting for Userinput';
Ziel_Wert = round(get(Ziel_Slide,'Value'));
set(Ziel_Text,'string',['Ziel ',num2str(Ziel_Wert),' J'])
return
end % Action=SetZiel
%-------------------- Action = SetMinMaxFaktor
if strcmp(Action,'SetMinMaxFaktor')
status
= 'Waiting for Userinput';
MinMaxFaktor = (round((get(MinMax_Slide,'Value'))*100))/100;
set(MinMax_text,'string',['MinMax Mutation ',num2str(MinMaxFaktor*100),'%'])
return
end % Action=SetMinMaxFaktor
%-------------------- Action = SetMutation_of_Value
if strcmp(Action,'SetMutation_of_Value')
status
= 'Waiting for Userinput';
MutationsFaktor = (round((get(Mutations_Slide_Paramter,'Value'))*100))/100;
set(Mutations_text_Parameter, ...
'string',['Value Mutation ',num2str(MutationsFaktor*100),'%'])
return
end % Action=SetMutation Value
%-------------------- Action = SetMutation_of_MF
if strcmp(Action,'SetMutation_of_MF')
status
= 'Waiting for Userinput';
MutationsFaktor_MF = (round((get(Mutations_Slide_MF,'Value'))*100))/100;
set(Mutations_text_MF, ...
'string',['MF Mutation ',num2str(MutationsFaktor_MF*100),'%'])
return
end % Action=SetMutation MF
%-------------------- Action = SetMutation_of_Defuzz
if strcmp(Action,'SetMutation_of_Defuzz')
status
= 'Waiting for Userinput';
DefuzzFaktor = (round((get(Mutations_Slide_Defuzz,'Value'))*100))/100;
set(Mutations_text_Defuzz, ...
'string',['Defuzz Mutation ',num2str(DefuzzFaktor*100),'%'])
return
end % Action=SetMutation Defuzz
end
% ES_CNTRL.M
Seite 170
Kapitel 14: Programm-Texte
14.3.5 EVALMFP.M von ES_FUZZY.M
EVALMFP erzeugt aus den Informationen eines Chromosoms (den Genen eines Individuums)
und einer als Gerüst dienenden Fuzzy-Matrix eine gültige Fuzzy-Matrix mit den Informationen aus diesem Chromosom.
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Funktion evalmfp
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 21.11.95
IN:
fis_matrix - Ein Geruest einer Fis-Matrix
input_zeile - Ein Chromosom, dass in die
Fis-Matrix eingetragen werden soll
Out: fis_matrix - Fis-Matrix mit Chromosomenparamtern
input_zeile - Chromosom wird zurueckgegeben
(c) by Jan-Erik Engels
Beschreibung: In ein Geruest eines Fuzzy-Systems werden aus
einem Chromosom die Parameter eingetragen, wobei
die Funktion VERTEIL.M aufgerufen werden kann,
wenn der Boolean UseVerteil dies zulaesst
function [fis_matrix,input_zeile]=evalmfp(fis_matrix,input_zeile)
global
global
global
global
global
global
global
MFTyp
MinMaxTyp
DefuzzTyp
true
MFStrings
MFTyp_Maske
UseVerteil
%% Erfassen der Geometrie des Genes und der <fis_matrix>
ZeilenZahl
= input_zeile(2)/2;
OutBlockZahl
= input_zeile(3);
BlockZahl
= input_zeile(2) + input_zeile(3);
NumInputs
= fis_matrix(3,1);
NumOutputs
= fis_matrix(3,2);
pointer
= 9+BlockZahl;
%% leere Matizen anlegen (speed !!!)
resultInMF = zeros(input_zeile(2),4);
resultOutMF = zeros(input_zeile(3),4);
%% InMFParams aus Geninformationen erstellen
typ_p = 9;
%% Nachbehandlungen
%% 1. Nicht benutzte Parameter durch Nullen ersetzen
%% 2. Typ "gbellmf" darf auf erstem Parameter keine "Null" haben
for i = 1:input_zeile(2),
resultInMF(i,1:4) = (input_zeile(pointer:(pointer+3))) ...
.*MFTyp_Maske(MFTyp(input_zeile(typ_p),:));
if
MFTyp(input_zeile(typ_p))==1 % gauss2mf: Nullen durch 1 ersetzen
resultInMF(i,1:4)=sort_0(resultInMF(i,1:4)+(resultInMF(i,1:4)==0));
elseif MFTyp(input_zeile(typ_p))==2 % gbellmf: Nullen durch 1 ersetzen
resultInMF(i,1:3)=sort_0(resultInMF(i,1:3)+(resultInMF(i,1:3)==0));
elseif MFTyp(input_zeile(typ_p))==3 % gbellmf: Trimf sortieren
resultInMF(i,1:4)=sort_0(resultInMF(i,1:4));
elseif MFTyp(input_zeile(typ_p))==5 % gaussmf: Nullen durch 1 ersetzen
resultInMF(i,1:2)=sort_0(resultInMF(i,1:2)+(resultInMF(i,1:2)==0));
elseif MFTyp(input_zeile(typ_p))==6 % trapmf: Nullen durch 1 ersetzen
resultInMF(i,1:4)=sort_0(resultInMF(i,1:4)+(resultInMF(i,1:4)==0));
end % if MFPTyp
pointer
= pointer+4;
Seite 171
Kapitel 14: Programm-Texte
typ_p
end % for i
= typ_p+1;
%% Funktionskurven auf Range gleichmaessig verteilen
%% Dazu wird eine Fuzzy-Spalte mit ihren Parametern und
%% ihren MF-Typen an die Funktion "verteil" uebergeben
if UseVerteil==true
Range=getfis(fis_matrix,'InRange');
Range=Range(1,2)-Range(1,1);
resultInMF(1:ZeilenZahl,:)=verteil(resultInMF(1:ZeilenZahl,:), ...
input_zeile(9:8+ZeilenZahl), ...
Range);
Range=getfis(fis_matrix,'InRange');
Range=Range(2,2)-Range(2,1);
resultInMF(ZeilenZahl+1:2*ZeilenZahl,:) = ...
verteil(resultInMF(ZeilenZahl+1:2*ZeilenZahl,:), ...
input_zeile(9+ZeilenZahl:8+2*ZeilenZahl), ...
Range);
end % if UseVerteil ...
%% OutMFParams aus Geninformationen erstellen
for j = 1:input_zeile(3),
resultOutMF(j,:) = (input_zeile(pointer:(pointer+3)));
pointer
= pointer+4;
end % for j
%% Funktionskurven auf Range gleichmaessig verteilen
%% Dazu wird eine Fuzzy-Spalte mit ihren Parametern und
%% ihren MF-Typen an die Funktion "verteil" uebergeben
If UseVerteil==true
Range=getfis(fis_matrix,'OutRange');
Range=Range(1,2)-Range(1,1);
resultOutMF(1:ZeilenZahl,:) = ...
verteil(resultOutMF(1:ZeilenZahl,:), ...
input_zeile(9+2*ZeilenZahl:8+3*ZeilenZahl), ...
Range);
end % if UseVerteil ...
%% In die Fuzzy-Matrix die gewonnenen Daten eintragen
fis_matrix = setfis(fis_matrix,'InMFParams',resultInMF);
fis_matrix = setfis(fis_matrix,'OutMFParams',resultOutMF);
%% Die MF-Typen in Fuzzy-Matrix eintragen
%% Zeiger auf 1. MF-Information im Gen setzen
pointer = 12+2*(NumInputs+NumOutputs)+BlockZahl;
for j = 9:(BlockZahl+8),
fis_matrix(pointer,:) = abs(MFStrings(input_zeile(j),:));
pointer
= pointer+1;
end % for j
%% Die geaenderten MF-Paramter in die <input_zeile> eintragen
sammler = [resultInMF ; resultOutMF];
pointer = 9 + BlockZahl;
for t
= 1: size(sammler,1)
input_zeile(pointer:pointer+3) = sammler(t,:);
pointer
= pointer+4;
end % for t
%% Die MinMax-Ausdruecke in die fis_matrix eintragen
fis_matrix=setfis(fis_matrix,'AndMethod',
...
deblank(MinMaxTyp(input_zeile(4),:)));
fis_matrix=setfis(fis_matrix,'OrMethod',
...
deblank(MinMaxTyp(input_zeile(5),:)));
fis_matrix=setfis(fis_matrix,'ImpMethod',
...
deblank(MinMaxTyp(input_zeile(6),:)));
fis_matrix=setfis(fis_matrix,'AggMethod',
...
deblank(MinMaxTyp(input_zeile(7),:)));
fis_matrix=setfis(fis_matrix,'DefuzzMethod', ...
deblank(DefuzzTyp(input_zeile(8),:)));
end % function eval_mfp
Seite 172
Kapitel 14: Programm-Texte
14.3.6 CHG_MFP.M von ES_FUZZY.M
%
%
%
%
%
%
%
%
%
%
%
%
%
function chg_mfp
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 21.11.95
IN:
p - Ein Chromosom als Matlab-Zahlenvektor
welche_mfp - Zeiger in das Chromosom
TypOut - Der neue MF-Typ
Out: p - Ein Chromosom mit veraenderter MF
(c) by Jan-Erik Engels
function p = chg_mfp(p,welche_mfp,TypOut)
global
global
global
global
MFStrings;
MFTyp;
Fit_Eintrag;
KeinEintrag;
Alter_Typ
Neuer_Typ
Start
buffer
%% Izt den Fehler,
%% manchmal macht,
buffer
p(Start:Start+3)
p(Fit_Eintrag)
p(welche_mfp+8)
%
%
%
%
Tabelle mit Namen von MF-Kurven
Index-Tabelle mit Hilfszuordnungen
Stelle im Chromosom, wo Fitness vermerkt ist
Vorgabewert, wenn Fitness unbekannt
= deblank(MFStrings(p(8+welche_mfp),:));
= deblank(MFStrings(TypOut,:));
= 9+p(2)+p(3)+((welche_mfp-1)*4);
= mf2mf(p(Start:(Start+3)),Alter_Typ,Neuer_Typ);
den mf2mf
korrigieren
= sort(buffer);
= [buffer zeros(1,4-length(buffer))];
= KeinEintrag;
= TypOut;
end % function chg_mfp;
14.3.7 Q_CALC.M von ES_FUZZY.M
%
%
%
%
%
%
%
%
%
%
%
%
%
Funktion Q_CALC.M
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 09.11.95
IN:
Flaeche
- Ausgangskennlinienfeld des Fuzzy-Systems
Temperatur - Matrix der zu berechnenden Temperaturwerte
Fuellhoehe - Matrix der zu berechnenden Fuellhoehen
Out: WarmeKapazitaet - Kennlinenfeld der Energien
(c) by Jan-Erik Engels
function WaermeKapazitaet=Q_CALC(Flaeche,Temperatur,Fuellhoehe)
c_wasser=4.182;
zwei_mal_g_durch_100=2 * 9.82 /100;
WaermeKapazitaet=c_wasser*Flaeche.*
...sqrt(zwei_mal_g_durch_100.*Fuellhoehe).*Temperatur;
end % function Q_CALC
Seite 173
Kapitel 14: Programm-Texte
14.4 Das MATLAB-Programm OPTIMAL.M
Das Programm OPTIMAL.M zeichnet eine Plot der idealen Ausgangsfunktion für das Problem der gleichmäßigen Energie-Entnahme aus einem Gefäß:
%
%
%
%
%
%
%
%
%
%
%
%
%
%
%
Funktion OPTIMAL.M
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 09.01.96
IN:
-
Out: (c) by Jan-Erik Engels
Beschreibung: Zeichnet die ideale Ausgangsfunktion
eines optimalen Fuzzy-Systems
function optimal
% Erst einmal Konstanten definieren
%% Konstante für die Waermekapazitaet von Wasser
c_wasser=4.182;
%% Konstante der Schwerebeschleunigung
g=9.82;
%% Vorgabewert fuer die Soll-Energiemenge,
%% die das Gefaess pro Zeiteinheit verlassen soll
WaermeKapazitaet=100;
%% Groesse der Oeffnung des Gefaesses
Oeffnung=0.09;
[Temperatur,Fuellhoehe]=meshgrid([1:3:200],[1:3:200]');
Q = (Oeffnung*c_wasser* sqrt((2*g*(Fuellhoehe./100)).*Temperatur));
fuzzyOut = ((200/Oeffnung)*WaermeKapazitaet) ./ ...
(c_wasser * Temperatur.* sqrt(2*g*(Fuellhoehe./100)));
%Beschneiden auf mögliche Ausgangswerte des Fuzzy-Systems
temp=fuzzyOut<200;
fuzzyOut=(fuzzyOut.*temp)+((~temp).*200);
figure;
surf(Temperatur,Fuellhoehe,Q);
view(320,30);
xlabel('Temperatur in ³C');
ylabel('Fuellhoehe in cm');
zlabel('Energie Output in Joule');
figure;
surf(Temperatur,Fuellhoehe,fuzzyOut);
xlabel('Temperatur in ³C');
ylabel('Fuellhoehe in cm');
zlabel('Fuzzy Output (Sollwerte)');
view(150,30);
end % optimal
Seite 174
Kapitel 14: Programm-Texte
14.5 Das MATLAB-Programm TEST_ANF.M
Das Programm TEST_ANF.M stellt dem ANFIS-Tool der MATLAB-Fuzzy-Toolbox das
gleiche Problem wie es im Abschnitt zu ES_FUZZY beschrieben wird zur Lösung.
function [OutputFismat, error, stepsize, Fit_Eintrag] = test_anf(NumEpochs)
%
%
%
%
%
%
%
%
%
%
%
Version 1.1 (c) Jan-Erik Engels 1995
Status: ( ) blocked
( ) testing
(X) ready for use
Last Revision: 19.12.95
Beschreibung:
Funktion zum Testen des von MATHWORKS bereitgestellten
Neuronalen Netzwerktools fuer die Optimierung von
von Fuzzy-Regeln.
% Allgemeine Parameter festlegen
t0
c_wasser
g
WaermeKapazitaet
Fuellhoehe
Oeffnung
=
=
=
=
=
=
clock;
4.182;
9.82;
10;
1;
0.09;
% Trainingsdatensatz berechnen
Cntr1 = 1;
Cntr2 = 1;
cntr = 1;
while Fuellhoehe<200,
Temperatur = 1;
while Temperatur<200,
fuzzyOut(Cntr1,Cntr2) = (127/Oeffnung)* ...
(WaermeKapazitaet/(c_wasser* ...
sqrt(2*g*(Fuellhoehe/100))*Temperatur));
TrainData(cntr,1:3)
= [Cntr1 Cntr2 fuzzyOut(Cntr1,Cntr2)];
cntr = cntr+1;
if fuzzyOut(Cntr1,Cntr2)>200 fuzzyOut(Cntr1,Cntr2)=200;
end % if
t_feld(Cntr1,Cntr2) = Temperatur;
f_feld(Cntr1,Cntr2) = Fuellhoehe;
Temperatur
= Temperatur+3;
Cntr1
= Cntr1+5;
end % Temperatur
Fuellhoehe = Fuellhoehe+3;
Cntr1
= 1;
Cntr2
= Cntr2+5;
end % Fuellhoehe
% Vorbereitungen fuer den Einsatz von ANFIS
NumMfs
= 5;
MfType
= 'gbellmf';
%NumEpochs = EpochenZahl;
StepSize
= 0.1;
InputFismat = genfis1(TrainData, NumMfs, MfType);
% ANFIS aufrufen
[OutputFismat, error, stepsize]= ...
anfis(TrainData, InputFismat, [NumEpochs nan StepSize]);
etime(clock,t0)
% Ergebnise visualisieren
figure;
plot (error)
title('Error vs EPOCHE')
figure;
plot(stepsize)
title('Stepsize vs EPOCHE')
Seite 175
Kapitel 14: Programm-Texte
% aus den Fuzzy-Ausgangs-Parametern die Fitness- ...
% oberflaeche berechnen
fit_field= q_calc(OutputFismat/1000,Temperatur,Fuellhoehe) ...
- 100;
figure
surf(fit_field);
% Und jetzt den FitnessWert berechnen
MIN
MAX
= min(min(fit_field));
= max(max(fit_field));
Fit_Eintrag = sum(sum(fit_field.*fit_field)) ...
*(std(fit_field(:))) ...
*abs(MAX-MIN);
if sign(MIN)==sign(MAX) Fit_Eintrag = Fit_Eintrag*2;
end % if sign(MIN ...
ruleview(OutputFismat);
end % function
Seite 176
Kapitel 15: Geschützte Begriffe und Warenzeichen
Kapitel 15: Geschützte Begriffe und Warenzeichen
Geschützte Begriffe, Warenbezeichnungen, Handelsnamen usw. sind in dieser Diplomarbeit
nicht besonders gekennzeichnet.
Dies berechtigt jedoch nicht zu der Annahme, daß diese geschützten Begriffe, Warenbezeichnungen, Handelsnamen usw. von jedermann frei verwendet werden dürfen.
Für die Fehlerfreiheit der nicht vom Diplomanten stammenden Programme und der vom Diplomanten entwickelten MATLAB-Programme wird keine Gewährleistung oder Haftung übernommen.
Die Rechte über die Vervielfältigung dieser Diplomarbeit (oder einzelner Teile daraus) und
die Rechte der Modifizierung der MATLAB-Programme zum Zwecke der Forschung und
Lehre werden hiermit ausdrücklich vom Diplomanten freigegeben.
Seite 177
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement