Entwicklung eines Systems zur evo- lutionären

F
Entwicklung eines Systems zur evolutionären Adaptation dreidimensionaler
künstlicher Lebewesen
Development Of A System For The Evolutionary Adaptation Of
Three-Dimensional Artificial Creatures
Tim Gottwald
Master Abschlussarbeit
Betreuer: Prof. Dr. Rainer Oechsle
Trier, Januar 2006
Danksagungen
Ein großer Dank geht an Professor Dr. Rainer Oechsle, der mich bei dieser Arbeit
betreut hat und der es mir ermöglicht hat, mein Studium mit diesem außergewöhnlichen und hochinteressanten Thema abzuschließen.
Auch meiner Freundin Angela Otting möchte ich herzlich danken, da sie sich
trotz aller fachlichen Schwierigkeiten bemüht hat, meine inhaltlichen und orthografischen Fehler aufzudecken, indem sie diese Seiten Korrektur gelesen hat.
Ein weiterer Dank geht an Ben Janus, einem ehemaligen Kommilitonen, der
mir einige hilfreiche Hinweise zur Arbeitsweise mit genetischen Algorithmen geben
konnte und an Florian Adolf, ebenfalls ein ehemaliger Kommilitone, der mich auf
die Open Dynamics Engine aufmerksam gemacht hat.
Meinen Eltern möchte ich einen besonderen Dank aussprechen, da sie es waren,
die mir das Studium erst ermöglicht haben.
Kurzfassung
Manche Tiere können sofort nach ihrer Geburt stehen und laufen; bei uns Menschen dauert es viele Monate, bis der erste Schritt getan ist. Mit den in dieser
Arbeit geschaffenen künstlichen Lebewesen wird das Problem der Fortbewegung
untersucht. Die Lebewesen müssen lernen, sich mit den ihnen gegebenen Körpern
fortzubewegen. Für diese schwierige Aufgabe stehen ihnen Verfahren wie genetische Programmierung oder künstliche neuronale Netze zur Verfügung. Die dabei
entwickelten Strategien sind häufig sehr interessant und einfallsreich und nicht
selten sehr amüsant anzusehen.
Um sich möglichst nahe am natürlichen Vorbild orientieren zu können, halten sich die künstlichen Lebewesen in einer dreidimensionalen Umwelt auf, in der
mit Hilfe physikalischer Simulationen ähnliche Bedingungen herrschen wie in der
hiesigen Natur.
Bei der Lösung dieser Aufgabe, dem Erlernen eines effektiven Bewegungsablaufs, zeigt sich wie schon in der Natur, die Vorbild vieler der hier erschaffenen
künstlichen Lebewesen ist, dass der Erfolg auch in der Form des Körpers liegt. Die
evolutionär getriebene Entwicklung, die in der Tierwelt schon die bizarrsten Geschöpfe hervorgebracht hat - hier sei an Beispiele aus dem Insektenreich erinnert wird in dieser Arbeit ebenfalls auf die künstlichen Lebewesen angewendet.
Um all diesen Aufgaben gerecht zu werden, kommen frei verfügbare Bibliotheken
wie Open Dynamics Enginge (ODE) für die physikalische Simulation, Java3D für
die grafische Darstellung im dreidimensionalen Raum sowie eigene Konzepte zur
genetischen Beschreibung der künstlichen Lebewesen und Implementierungen der
genetischen Algorithmen und neuronalen Netze zum Einsatz.
Künstliches Leben“ ist seit jeher ein interdisziplinärer Forschungszweig und
”
allein in dieser Arbeit, die nur einen kleinen Bereich dieser Wissenschaft abdeckt,
finden sich viele Berührungspunkte zu Physik und Biologie.
Inhaltsverzeichnis
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
2
Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1 Physikalische Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Java 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Neuronale Netze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4 Genetischer Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5 Wettkampfsituation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.6 Verteiltes Rechnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.7 Offene Evolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
4
4
5
5
6
6
6
3
Künstliches Leben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1 Natürliches Leben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Was ist künstliches Leben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Geschichte des KL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4 Formen künstlichen Lebens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.1 Zelluläre Automaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.2 Biomorphe und L-Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.3 tierra, avida, amoeba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.4 Animate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4.5 Von Viren und Würmern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5 Verwandte Arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.1 Karl Sims virtuelle Kreaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.2 Gene Ruebsamens embodied agents . . . . . . . . . . . . . . . . . . . . . . .
3.5.3 Sigel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.4 Marbachs modulare Roboter . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
8
9
10
11
11
13
14
15
17
17
18
19
20
20
4
Der Genetische Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1 Genetik in der Natur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1 Geschichte der Genetik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.2 Aufbau und Arbeitsweise von Genen . . . . . . . . . . . . . . . . . . . . . .
4.1.3 Evolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Genetik in der Informatik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
22
22
22
26
27
Inhaltsverzeichnis
V
4.3 Fitnessfunktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.1 Lineare skalierte Fitness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.2 σ-Skalierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.3 Exponentielle Skalierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.4 Geteilte Fitness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.5 Mehrkriterienoptimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.6 Fitnessfunktion mit Zusatzbedingungen . . . . . . . . . . . . . . . . . . . .
4.4 Selektionsverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.1 Stochastic Sampling with Replacement . . . . . . . . . . . . . . . . . . . .
4.4.2 Remainder Stochastic Sampling . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.3 Stochastic Universal Sampling . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.4 Boltzmann Selektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.5 Lineares Ranking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.6 Wettkampf-Selektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.7 Steady State Reproduktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.8 Deterministisches Crowding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5 Rekombination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.1 One-point-crossover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.2 Two-point-Crossover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.3 k-point-Crossover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.4 Parametrisiertes Uniform Crossover . . . . . . . . . . . . . . . . . . . . . . .
4.5.5 Shuffle Crossover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.6 Punctuated Crossover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.7 Inversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6 Mutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6.1 Non Uniform Mutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.7 Genetische Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
29
30
30
31
32
32
33
34
34
35
35
36
36
36
37
37
37
38
38
38
39
39
40
40
41
41
5
Künstliche Neuronale Netze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1 Neuronale Netze in der Natur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Aufbau und Funktionsweise einer Nervenzelle . . . . . . . . . . . . . . . . . . . .
5.3 Neuronale Netze in der Informatik . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Netzaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4 Lernverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.5 Backpropagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6 Netzarchitekturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.1 (Multi Layer) Perzeptron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.2 Elman-Netze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.3 Selbstorganisierende Karten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.7 Optimierung neuronaler Netze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
43
43
45
45
46
47
48
48
49
50
52
6
Open Dynamics Engine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.1 Eigenschaften von ODE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Bestandteile von ODE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2.1 World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
55
56
56
Inhaltsverzeichnis
6.2.2
6.2.3
6.2.4
6.2.5
6.3 ODE
VI
Body . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Joint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Collision Detection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gesamtsystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
in der Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
58
61
62
62
7
Java3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.1 Der Java3D-Szenengraph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 Interaktion in Java 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.3 Vektormathematik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4 Java3D und ODE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
64
64
67
69
69
8
Entwurf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1 Kreaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1.1 Genetische Beschreibung der Kreaturen . . . . . . . . . . . . . . . . . . . .
8.1.2 Kreatur-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.1.3 Einbinden in die physikalische Simulation . . . . . . . . . . . . . . . . . .
8.1.4 Bewegung und Denken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 Die Simulationsumgebung Evita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3 Der Genetische Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
70
70
70
72
72
73
75
77
9
Implementierung und Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1 XML-Spezifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2 ODE-Binding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.3 Videogenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.4 Realisierung des genetischen Algorithmus . . . . . . . . . . . . . . . . . . . . . . .
9.5 Grafische Benutzeroberfläche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.5.1 Starten eines genetischen Algorithmus . . . . . . . . . . . . . . . . . . . . .
9.5.2 Ansicht der Resultate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.6 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.6.1 Statische Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.6.2 Testen der Softcomputingverfahren . . . . . . . . . . . . . . . . . . . . . . . .
9.6.3 Systemtest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
80
81
82
83
84
84
85
86
86
86
87
10 Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1 Gehirntypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1.1Gehirn mit neuronalen Netzen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1.2Gehirn mit genetischer Programmierung . . . . . . . . . . . . . . . . . . .
10.2 Erlernen eines Bewegungsablaufs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3 Körperevolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.1Aufbau der Chromosomen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.2Genetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.3Zufällige Erzeugung von Chromosomen . . . . . . . . . . . . . . . . . . . .
10.3.4Bewertung der Chromosomen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.5Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
88
88
88
90
93
94
94
95
95
95
96
Inhaltsverzeichnis
10.4 Bewegen vordefinierter Körper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.1TwoArm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.2Spinnentiere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.3Vierbeiner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.4Sonstige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
VII
96
97
100
102
103
11 Zusammenfassung und Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Abbildungsverzeichnis
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
Beispiele verschiedener Klassen (Quelle: [Wol02] S. 284) . . . . . . . . . . .
Rekursives Muster (Quelle: [Wol02] S. 263) . . . . . . . . . . . . . . . . . . . . . .
Beispielabfolge eines Life-Spiels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Langtons Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiele für Biomorphe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiele für L-Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Boid-Schwarm beim Umfliegen von Hindernissen . . . . . . . . . . . . . . . . .
Beispielgraphen und die daraus entstehende Morphologie. (Quelle:
[Sim94b] S. 2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.9 Beispiele sich bekämpfender Kreaturen (Quelle: [Sim94a] S. 37) . . . .
3.10 Bewegungsablauf eines Dreibeiners (Quelle: [MCV01] S. 178) . . . . . .
3.11 Beispiel eines generierten Roboters (Quelle: [Mar05] S. 71) . . . . . . . .
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
4.15
Erbgang mit zwei Merkmalen (dihybrider Erbgang) (Quelle: [HB89]
S. 355) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufbau der DNS (i.A.a. [HB89] S. 357) . . . . . . . . . . . . . . . . . . . . . . . . .
Chromosomenfeinstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Crossing-over mit Austausch gleicher Chromatiden-Abschnitte
(i.A.a. [HB89] S. 441) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zeichenstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Crossover (Quelle: [IG04] S. 40) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mutation (Quelle: [IG04] S. 41) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Überlebens-/Vermehrungswahrscheinlichkeit (Quelle: [IG04] S. 39) .
Two-Point-Crossover (Quelle: [IG04] S.88) . . . . . . . . . . . . . . . . . . . . . .
Two-Point-Crossover mit Ringinterpretation des Chromosoms
(i.A.a. [IG04] S.88) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4-Point-Crossover (i.A.a. [IG04] S.89) . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiel parametrisiertes Uniform Crossover (i.A.a. [IG04] S.89) . . . .
Inversion (Quelle: [IG04] S.98) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispielprogramme als Bäume (Quelle: [IG04] S. 129) . . . . . . . . . . . . .
Crossover: Austausch ausgewählter Teilbäume (Quelle: [IG04] S.
131f) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
12
12
13
13
14
16
18
19
20
21
24
25
25
27
28
28
29
34
38
38
39
39
40
42
42
Abbildungsverzeichnis
5.1
5.2
IX
5.9
Ein typisches Neuron (Nervenzelle) (Quelle:[JS91] S. 36) . . . . . . . . . .
Beispiel-Topologien und ihre Verbindungsmatrizen (Quelle:[Zel94]
S. 79) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schema des Perzeptrons (links) und Ausgabeneuron des
Perzeptrons (rechts) (Quelle:[Zel94] S. 98) . . . . . . . . . . . . . . . . . . . . . . .
Dreistufiges Perzeptron (i.A.a.:[Zel94] S. 102) . . . . . . . . . . . . . . . . . . . .
Architektur eines Elman-Netzes (i.A.a.:[Zel94], S. 141) . . . . . . . . . . . .
Netzstruktur der selbstorganisierenden Karten (i.A.a.:[Zel94] S. 180)
Netzstruktur der selbstorganisierenden Karten (i.A.a.:[Zel94] S. 182)
Distanzfunktionen hgauss , hcylinder , hcone und hcos (Quelle:[Zel94] S.
183) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Entfaltung einer Kohonenkarte (Quelle:[Zel94] S. 184) . . . . . . . . . . . .
52
53
6.1
6.2
6.3
6.4
6.5
6.6
6.7
6.8
Kugelgelenk (Quelle:[Smi04] S. 28) . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Achsengelenk (Quelle:[Smi04], S. 29) . . . . . . . . . . . . . . . . . . . . . . . . . . .
Radaufhängung (Quelle:[Smi04] S. 32) . . . . . . . . . . . . . . . . . . . . . . . . . .
Schiebeverbindung (Quelle:[Smi04] S. 30) . . . . . . . . . . . . . . . . . . . . . . .
Universalgelenk (Quelle:[Smi04] S. 30) . . . . . . . . . . . . . . . . . . . . . . . . . .
Kontaktverbindung (Quelle:[Smi04] S. 33) . . . . . . . . . . . . . . . . . . . . . . .
Gelenkmotor (Quelle:[Smi04] S. 36) . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ODE Gesamtsystem (Quelle:[DS04] S. 37) . . . . . . . . . . . . . . . . . . . . . .
58
59
59
60
60
61
61
62
7.1
7.2
7.3
7.4
Elemente eines Szenengraphen (Quelle: [Bou99] S. 1-4) . . . . . . . . . . .
Beispiel-Szenengraph (Quelle:[Bou99] S. 1-5) . . . . . . . . . . . . . . . . . . . .
Geometrien (Quelle:[Bou99] S. 2-26) . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiele für steigende, fallende oder unbestimmter Wellenformen
eines Alpha-Objekts (Quelle:[Bou99] S. 5-4) . . . . . . . . . . . . . . . . . . . . .
65
66
67
68
8.1
8.2
8.3
8.4
8.5
UML-Beschreibung der Chromosomen . . . . . . . . . . . . . . . . . . . . . . . . . .
UML-Beschreibung der Kreaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Klassenübersicht für das ODE-Binding . . . . . . . . . . . . . . . . . . . . . . . . .
Von XML nach ODE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ablauf eines GA zum Erlernen eines Bewegungsablaufs . . . . . . . . . . .
72
73
74
74
79
9.1
9.2
GUI zum Starten eines genetischen Algorithmus . . . . . . . . . . . . . . . . . 85
GUI zum Starten eines Ergebnisses . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
10.1
10.2
10.3
10.4
10.5
10.6
10.7
10.8
10.9
Beispiel eines Berechnungsbaums . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Generierter Körperbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
TwoArm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fitnessverlauf gerichtete Fitness in X-Richtung . . . . . . . . . . . . . . . . . .
Fitnessverlauf gerichtete Fitness in Y-Richtung . . . . . . . . . . . . . . . . . .
Fitnessverlauf Ruebsamen, Y-Richtung . . . . . . . . . . . . . . . . . . . . . . . . .
Spinnentiere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fitnessverlauf Trippelschritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fitnessverlauf Trippelschritte und Drückbewegungen . . . . . . . . . . . . .
5.3
5.4
5.5
5.6
5.7
5.8
44
46
48
49
50
51
51
92
96
97
98
99
99
100
101
101
Abbildungsverzeichnis
10.10Fitnessverlauf krebsgleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.11Vierbeiner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.12Fitnessverlauf rückwärtige Bewegung . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.13Fitnessverlauf vorwärtsgerichtete Bewegung . . . . . . . . . . . . . . . . . . . . .
X
102
102
103
104
1
Einleitung
Das Thema künstliches Leben umfasst viele Facetten der Informatik, aber auch
der menschlichen Fantasie. Diese Arbeit beschäftigt sich vertieft mit einem kleinen Teilgebiet dieser Wissenschaft. Hier finden sich Versuche zur evolutionären
Adaptation dreidimensionaler künstlicher Lebewesen.
Die genaue Aufgabenstellung in Kapitel 2 beschreibt die Problemstellung und
Ziele dieser Arbeit. Dabei wird genauer auf den Begriff evolutionäre Adaptation
eingegangen und erläutert, welche Ansätze verfolgt werden.
Kapitel 3 führt in die Thematik des künstlichen Lebens ein. Es handelt von
den Ursprüngen dieser Idee aus Religion und Literatur und stellt viele Bereiche,
Methoden und Möglichkeiten aus Sicht der Informatik vor. Hier begegnen dem
informatikvertrauten Leser bekannte Namen wie von Neumann, Turing oder Babbage. Das Kapitel schließt mit einem kurzen Abriss von Arbeiten, die ähnliche Ziele
wie diese verfolgten. Damit umfasst dieser Teil Themen vom Beginn der Informatik
mit Babbages Rechenmaschine bis zu modernsten Robotersimulationen.
Eines der hier verwendeten Softcomputingverfahren, die genetischen Algorithmen, werden in Kapitel 4 vorgestellt. Dabei wird zunächst der biologische und historische Hintergrund beleuchtet, bevor einzelne Konzepte wie Fitnessberechnung,
Selektionsverfahren oder genetische Operatoren wie Crossover und Mutation behandelt werden.
Kapitel 5 gibt einen kurzen Überblick über den biologischen und historischen
Hintergrund sowie eine kurze Einführung in Architekturen und Lernverfahren
künstlicher neuronaler Netze. Das Kapitel endet mit der Vorstellung eines Verfahrens, das künstliche neuronale Netze mit Hilfe genetischer Methoden optimiert,
der Neuroevolution.
Die zur physikalischen Simulation verwendete Bibliothek Open Dynamics Engine (ODE) wird in Kapitel 6 vorgestellt, es gibt einen kurzen Überblick über den
Umfang und die Arbeitsweise der Bibliothek.
Die Darstellung der physikalischen Simulation soll in einer dreidimensionalen
Umgebung stattfinden. Hier fiel die Wahl auf Java3D. Auf diese Technologie wird
in Kapitel 7 genauer eingegangen. Es werden alle grundlegenden Konzepte und
Möglichkeiten erläutert sowie das Verfahren, ODE und Java3D zur Zusammenarbeit zu bewegen.
1 Einleitung
2
Der objektorientierte und konzeptionelle Entwurf wird in Kapitel 8 vorgestellt.
Hier wird das System erklärt, das alle bisher genannten Bereiche zusammenführt
und mit dem die künstlichen dreidimensionalen Lebewesen simuliert und bewertet
werden. Es erfolgt eine Einführung in die genetische Beschreibung der Kreaturen,
wie sie denken“ und wie sie ihre Bewegungen koordinieren können.
”
Kapitel 9 geht dann genauer auf die Implementierung der einzelnen Teile ein. Es
erläutert die Spezifikation der Gene in XML, beschreibt einige knifflige Programmteile und geht detaillierter auf die Realisierung des genetischen Algorithmus ein,
der in dieser Arbeit verwendet wird.
Eine genaue Beschreibung der hier implementierten Kontrollmechanismen in
Form von Gehirnen, die Evolution des Körperbaus einer Kreatur und die Ergebnisse einiger Versuche mit und ohne vordefinierter Körper finden sich in Kapitel 10.
Ein kurzes Fazit und ein Ausblick auf mögliche Erweiterungen dieser Arbeit
werden in Kapitel 11 gegeben.
2
Aufgabenstellung
Evolutionäre Adaptation dreidimensionaler, künstlicher Lebewesen. Dieser Begriff
beschreibt die Aufgabe und die Zielsetzung dieser Arbeit.
Unter evolutionären Anpassungen (Adaptation) versteht man Eigenhei”
ten in Körperbau und Verhalten, die als Antwort“ auf spezielle Umweltge”
gebenheiten gedeutet werden können.“1
Das Erlernen von Bewegungsabläufen und -strategien steht in dieser Arbeit im
Vordergrund. Und es stellen sich die Fragen, welche Voraussetzungen gelten müssen, um eine gute Strategie zu entwickeln, welche Technologien können eingesetzt
werden, um diese auszubilden, wie müssen Körper aufgebaut sein, die sich besonders effektiv bewegen können? Durch all diese Erkenntnisse soll erreicht werden,
dem Phänomen der Evolution durch Computersimulationen näher zu rücken, in
der Absicht Gründe zu finden, warum sich manche Lebewesen und Formen durchgesetzt haben und andere wiederum nicht.
Inspiriert von den Ergebnissen von Karl Sims sollen künstliche Lebewesen in
einer physikalisch realistischen Umgebung erzeugt werden, deren Verhalten und
Aussehen von Evolution bestimmt ist. Das Hauptziel ist es, die Ergebnisse von Karl
Sims nachzuvollziehen und Kreaturen zu erschaffen, die sich in einer gegebenen
Umgebung etablieren. Hierzu sollen sie in der Lage sein, ihre Anatomie als auch
ihr Verhalten entsprechend anzupassen.
Aus der obigen Aufgabenstellung ergeben sich zunächst vier Themenschwerpunkte, die es zu lösen gilt. Diese ersten Ergebnisse werden aller Vorraussicht nach
den weiteren Verlauf der Arbeit bestimmen. Aber zunächst liegt das Hauptaugenmerk auf:
1.
2.
3.
4.
der physikalischen Simulation,
deren Darstellung mit Java 3D,
dem Erlernen des Verhaltens mit Hilfe neuronaler Netze und
der anatomischen Anpassung durch einen genetischen Algorithmus.
Diese Ziele sollten in jedem Fall erfüllt werden. Das weitere Vorgehen hängt
allerdings stark von den Ergebnissen dieser Ziele ab. So wäre es z.B. möglich, die
1
http://de.wikipedia.org/wiki/Evolutionäre Anpassung
2.2 Java 3D
4
aufkommende Rechenlast zu verteilen, um die einzelnen Probleme von unterschiedlichen Rechnern bearbeiten zu lassen.
2.1 Physikalische Simulation
Der erste Schwerpunkt liegt in der Simulation der physikalischen Umgebung. Diese Aufgabe könnte von Open Dynamics Engine (ODE) übernommen werden. Die
genaue Betrachtung gerade dieser Bibliothek lohnt sich, da sie, im Gegensatz zu
vergleichbaren Angeboten, nicht nur frei verfügbar, sondern auch auf Java portierbar ist. Innerhalb dieser Betrachtung müssen die Möglichkeiten, Einschränkungen,
Vorteile und Nachteile dieser Bibliothek untersucht werden, um letztendlich zu
entscheiden, inwiefern sie für diese Aufgabenstellung geeignet ist, oder ob Alternativen untersucht werden müssen.
Die Bibliothek muss es ermöglichen, die einzelnen Körperteile zu beschreiben,
deren physikalische Maße zu bestimmen und sie untereinander zu verbinden. Hierzu sollten mehrere Verbindungstypen eingesetzt werden können, um z.B. Kugeloder Scharniergelenke zu simulieren. Schließlich muss es möglich sein, diese Verbindungen anzusteuern, um letztendlich die Bewegungen eines Individuums zu
erzeugen.
Die Umgebung, in der die Kreaturen agieren, sollte ebenfalls relativ einfach
erzeugt werden können. Das Einlesen von 3D-Formaten wie z.B. VRML wäre da
sehr hilfreich.
Sollten diese Voraussetzungen erfüllt werden, steht dem Einsatz der Bibliothek
nichts mehr im Weg und ein wichtiger Schritt wäre vollzogen.
2.2 Java 3D
Der nächste Themenschwerpunkt, der sich auch als eher praktisches Problem herausstellt, ist die Darstellung, die mit Hilfe von Java 3D realisiert werden soll. Hier
könnte eine Verbindung zu ODE hilfreich sein und viel unnötige Arbeit ersparen.
D.h. die physikalische Umgebung, die in ODE simuliert wird, soll ohne weiteren
Programmieraufwand in Java 3D dargestellt werden können.
Zusätzlich zur Darstellung wird eine variable Kameraführung benötigt, die manuell angesteuert werden soll oder die die Verfolgung einzelner Kreaturen ermöglicht. Mit Hilfe von Texturen und Lichteffekten könnte die Darstellung zusätzlich
verbessert werden.
Die Generierung von Videos wäre zur Präsentation oder zur Analyse der Ergebnisse hilfreich. Möglichkeiten, mit der sich diese Aufgabe realisieren lässt, müssen
entsprechend untersucht und verifiziert werden. Hier müssen Alternativen wie z.B.
Einzelbildgenerierung, Vidiocapture oder der Einsatz des Java Media Frameworks
(JMF) gegenübergestellt werden, um zu entscheiden, welche sich am ehesten realisieren lässt.
2.4 Genetischer Algorithmus
5
Viele Eigenheiten, Vorteile oder auch Probleme werden wohl erst beim praktischen Einsatz von ODE und Java 3D auftauchen. Dadurch wird sich die Bearbeitung dieser beiden Teilbereiche wohl über den gesamten Zeitraum der Arbeit
erstrecken.
2.3 Neuronale Netze
Ein besonderer Schwerpunkt liegt im Erlernen der richtigen Bewegung oder allgemein dem Verhalten der Kreaturen. Hier ist es naheliegend, ein künstliches neuronales Netz zu verwenden, das die Funktionsweise der Gehirne von Wirbeltieren
simuliert. Welcher Netztyp und welches Lernverfahren hierzu am geeignetsten sind,
gilt es zusätzlich zu erforschen.
Neben der Wahl des Netztyps müssen verschiedene Konfigurationen und Parameter getestet werden, um einen möglichst guten Lernfortschritt zu erzielen. Da
ein solches Netz eine Art Regler darstellt, ist es besonders wichtig, die Informationen zu wählen, die der Regler als Eingabe erhält und die er auswerten muss,
um entsprechend zu reagieren. Die Simulation diverser Sinnesorgane wäre hier angebracht, um z.B. die eigene Ausrichtung oder Geschwindigkeit zu erfahren oder
äussere Einflüsse wie andere Kreaturen, die Umgebung, Hindernisse usw. aufzunehmen.
Andere Arbeiten haben sich an dieser Stelle für genetische Algorithmen bzw.
genetische Programmierung entschieden, obwohl ein neuronales Netz dem biologischen Vorbild, dem Gehirn, am nächsten kommt. Die Entscheidung gegen ein
neuronales Netz könnte aber auch auf schlechten Erfahrungen beruhen, die den
Einsatz dieser Technologie verhinderten. Um nicht in eine Sackgasse zu geraten,
muss daher ein relativ schnelles Einlenken möglich sein, um auf Alternativen umschwenken zu können.
2.4 Genetischer Algorithmus
Ein weiterer Aspekt ist die Definition eines genetischen Algorithmus, der für die
Evolution der Morphologie der einzelnen Kreaturen verantwortlich ist.
Voraussetzung für den Einsatz eines genetischen Algorithmus ist eine entsprechende Beschreibung des Körperbaus, z.B. ein gerichteter Graph, wie er von Karl
Sims verwendet wurde. Der Einsatz der genetischen Methoden: Selektion, Mutation
und Cross Over sollte anhand dieser Beschreibung möglichst einfach zu realisieren
sein.
Ähnlich wie bei den neuronalen Netzen ist es hier nötig, viele Konfigurationsmöglichkeiten bereitzustellen, um verschiedene Aspekte der Genetik einzubringen.
Diese umfassen z.B. unterschiedliche Selektionsstrategien oder unterschiedlich hohe Mutationsraten.
Zu Beginn der Arbeit soll eine Fitnessfunktion die evolutionäre Adaptation
beeinflussen und damit sowohl dem neuronalen Netz als auch dem genetischen
2.7 Offene Evolution
6
Algorithmus als Richtlinie dienen. Ob es möglich ist, auf diese Funktion zu verzichten oder ihren Einfluss zumindest abzuschwächen, könnte ebenfalls noch Teil
dieser Arbeit werden.
2.5 Wettkampfsituation
In der Literatur finden sich häufig Hinweise, dass die Evolution durch Wettkampfsituationen besonders angetrieben wird. Diese Erkenntnis soll auch in dieser Arbeit
nicht außer Acht gelassen werden.
Aus diesem Grund sollten viele unterschiedliche Wettkampfsituation simuliert
werden. Hierunter fallen z.B. Aufgaben wie Wettläufe“, Fortbewegung in schwie”
rigem Gelände oder der Umgang mit Hindernissen. Angesichts der bevorstehenden
Fußballweltmeisterschaft könnte aber auch ein vereinfachtes Fußballspiel simuliert
werden, in dem zwei oder mehrere Kreaturen gegeneinander antreten oder noch
einfacher, ein Torwandschießen bestreiten.
Durch den Einsatz eines genetischen Algorithmus, in dem die einzelnen Lebewesen und ihr Verhalten bewertet werden, kommt es ohnehin zu einer Wettkampfsituation.
2.6 Verteiltes Rechnen
Die weiteren anstehenden Schritte hängen nicht nur mit der eigentlichen Zielsetzung der Arbeit, sondern auch mit den ersten Ergebnissen zusammen. Da sich mit
dem Einsatz von 3D-Technologie, der Berechnung der physikalischen Umgebung,
einem künstlichen neuronalen Netz und dem genetischen Algorithmus einiges an
Rechenlast aufsummiert, könnte es notwendig sein, diese einzelnen Aufgaben auf
mehrere Rechner zu verteilen, um die Performance zu verbessern.
Hierzu könnten erneut einige Technologien zum Einsatz kommen. Durch die
Verwendung von Java liegt der Einsatz von RMI nahe. Eine komfortablere Lösung
mit Hilfe von Jini und Java Spaces wäre ebenfalls denkbar. Hier könnten die benötigten Aufgaben als Dienste von mehreren Rechnern angeboten werden. Ein Dienst
wäre z.B. das Berechnen der physikalischen Simulation oder die Berechnungen des
neuronalen Netzes. Um aber weiterhin die Rechenleistung gering zu halten, ist auch
das Versenden einfacher Textnachrichten denkbar. Diese Möglichkeiten sollten bei
Bedarf untersucht werden.
2.7 Offene Evolution
Ein Fernziel dieser Arbeit soll die Ausweitung des erstellten Systems auf eine offene
Evolution sein. Das bedeutet, dass die Fitnessfunktion, die bisher die Evolution im
neuralen als auch im anatomischen Bereich beeinflusst hat, wegfallen soll, und das
Überleben selbst die Fitness der einzelnen Kreaturen bestimmt. Hinsichtlich dieses
großen Zieles müssen die Kreaturen um einige Eigenschaften erweitert werden,
2.7 Offene Evolution
7
die ihnen automatisch einen Antrieb geben sollen. Genaues lässt sich hier noch
nicht bestimmen, aber es könnte eine innere Bewertung durch Energieauf- und
-abnahme erfolgen oder die Kreaturen erhalten verschiedene Triebe wie Hunger
oder Ähnliches, von denen sie dann gesteuert werden könnten.
Ein ähnliches Verhalten findet sich bereits in dem KL-Spiel Creatures. Dort
verhalten sich die Norns“ entsprechend ihren Bedürfnissen wie z.B. Hunger, Angst
”
oder Langeweile.
Zur Lösung dieser Aufgabe ist eine schrittweise Herangehensweise sinnvoll. In
jedem Schritt können weitere Erkenntnisse durch ausgiebige Analysen gewonnen
werden. Auf diesem Weg käme man dem Ziel der offenen Evolution schrittweise
näher und hätte, sollte die Zeit am Ende nicht reichen, etwas hinterlassen, was als
Grundlage für weitere Arbeiten an diesem Projekt dient.
3
Künstliches Leben
Die Idee, künstliches Leben zu erschaffen, verfolgt die Menschheit schon seit Jahrhunderten. Hierzu gibt es Beispiele in der Religion, wie den Golem, der einer jüdischen Legende zu Folge, aus Lehm erschaffen wurde (16. Jhd) oder in der Literatur
wie z.B. Mary Shelleys Frankenstein (1818). In der modernen Science Fiction finden sich unzählige Beispiele für künstliches Leben: David, der Roboterjunge in
Steven Spielbergs AI oder der Computer H.A.L. in Stanley Kubricks Meisterwerk
2001 - a Space Odyssee (vgl. [Mai03] S. 188ff), um nur einige zu nennen.
Schon in den Anfängen der Informatik gab es erste Ideen und Hoffnungen,
künstliches Leben zu erzeugen. Wobei es sowohl damals als auch heute Skeptiker
gibt, die dies bezweifeln. Lady Lovelace, Partnerin von Charles Babbage, der die erste programmgesteuerte Rechenmaschine entworfen und gebaut hat, glaubte nicht,
dass Maschinen in der Lage seien, kreativ zu handeln. Sie war der festen Überzeugung, dass Computer nur das tun können, wozu sie programmiert wurden. Heute
wissen wir, dass Computer z.B. mit Hilfe der Simulation von neuronalen Netzen
im Stande sind, intuitiv“ zu handeln. Diese Handlungsweise ist zwar auch pro”
grammiert, aber die ausgeführten Handlungen selbst werden nicht mehr explizit
vorgeschrieben (vgl. [Mai03] S. 8f).
3.1 Natürliches Leben
Bevor der Begriff künstliches Leben“ definiert werden kann, sollte klar sein, wie
”
sich natürliches Leben auszeichnet und welche Voraussetzungen hierzu notwendig
sind. Im Laufe der Geschichte wurde die Definition des Lebens, je nach Stand
der Wissenschaft, immer wieder neu formuliert und bis heute gibt es noch keine
endgültige Entscheidung darüber, was das Leben tatsächlich auszeichnet. So ist
z.B. noch ungeklärt, wo Viren einzuordnen sind.
Die Reihenfolge der folgenden Definitionen des Lebens untermauern die ständigen neuen Erkenntnisse der Wissenschaft in Bezug auf das Leben:
• Physiologisch werden Lebewesen durch Eigenschaften wie Atmung, Bewegung
usw. beschrieben. Diese sehr eingeschränkte Ansicht wird schon allein durch
die Einbeziehung von Pflanzen revidiert.
3.2 Was ist künstliches Leben
9
• Diese werden allerdings in einer späteren Definition einbezogen, nämlich der
Wechselwirkung eines Organismus mit seiner Umwelt in Form eines Stoffwechsels als Beweis des Lebens.
• Der biochemische Ansatz berücksichtigt die Fähigkeit, Erbinformationen in Nukleinsäuren (DNA, RNA) zu speichern.
• Die genetische Definition von Leben beharrt nicht auf Nukleinsäuren als Träger
der Erbinformation. Sie legt ihren Schwerpunkt auf die Mutation, Replikation
und Selektion des Erbmaterials.
• Damit ist die Fortpflanzung ein weiterer wesentlicher Aspekt des Lebens.
• Die Wärmelehre (Thermodynamik) erlaubt eine weitere Definition des Lebens,
die besagt, dass alle Lebewesen dem 2. Hauptsatz der Thermodynamik unterliegen. Dieser behauptet, dass die Entropie, also die Unordnung, im Laufe der
Zeit zunimmt und sich nicht umkehren lässt.
(vgl. [Ada98] S. 5, [HB89] S. 11ff, [Kin96] S. 15ff, [Thr94] S. 20ff)
Neben der eigentlichen Definition des Lebens stellt der Ursprung des Lebens
eines der grössten Rätsel dar und bildet den wohl grössten Streitpunkt zwischen
Religion und Wissenschaft. Es wurde zwar nachgewiesen, dass sich unter den Bedingungen der Uratmosphäre durch Energieeinwirkung komplexe Moleküle wie die
Aminosäuren entwickeln können. Der Übergang von Aminosäuren zu Proteinen,
den Bausteinen des Lebens, oder gar einer daraus bestehenden Zelle mit der Eigenschaft sich selbst zu vermehren, ist bis heute ungeklärt.
Fred Hoy hat die Wahrscheinlichkeit der Bildung einer lebenden Zelle aus vorhandenen Aminosäuren folgendermaßen veranschaulicht:
Eine Schutthalde enthält alle Einzelteile einer Boeing 747, aber völlig
”
zerstückelt und ungeordnet. Ein Wirbelsturm fegt über die Halde dahin. Wie
groß ist nun die Wahrscheinlichkeit, daß man anschließend eine vollständig
montierte, flugbereite Boeing 747 dort vorfindet? So gering, daß man sie
nicht zu berücksichtigen braucht, selbst wenn ein Tornado über genügend
Schutthalden hinwegwirbelte, um damit das ganze Universum auszufüllen“
(vgl. [Kin96] S. 29)
3.2 Was ist künstliches Leben
Nachdem feststeht, dass sich natürliches Leben nur schwer definieren lässt, stellt
sich die Frage nach den Voraussetzungen, die künstliche Lebewesen erfüllen müssen. Dabei lässt sich natürlich darüber streiten, ob ein Programm in einem Computer wirklich als lebendig bezeichnet werden sollte. Einige Eigenschaften, die künstliches Leben umfassen könnte, wurden auf der zweiten internationalen Konferenz
zu diesem Thema herausgestellt:
•
•
•
•
Selbstorganisation
Evolution
Evolutionäre Dynamik
Morphogenese
3.3 Geschichte des KL
10
• Lernen und Kommunikation
• u.v.a.
Etwas vergleichbares wie der Turing-Test, der künstliche Intelligenz nachweisen
können soll, wurde für künstliches Leben zwar angedacht, aber nicht realisiert (vgl.
[Kin96] S. 31f, [Thr94] S. 10ff).
3.3 Geschichte des KL
Die ersten Versuche, künstliches Leben im Computer zu erschaffen“, werden den
”
Pionieren der Informatik Alan Turing und John von Neumann zugeschrieben.
Alan Turing hat mit seiner Turing-Maschine einen universellen Automaten entworfen, der neben seines simplen Aufbaus auch mit allen anderen Berechnungsmodellen gleichwertig ist bzw. sich alle anderen Berechnungsmodelle auf die TuringMaschine reduzieren lassen (These von Church).
Die Turing-Maschine besteht aus einem beliebig langen Band, auf das mit einem
Kopf gelesen und geschrieben werden kann. Welche Aktion der Kopf bei welcher
Bandeingabe ausführt, wird in einem endlichen Automaten, einer Zustandstabelle,
festgelegt.
Neben diesem Modell hat Turing noch zusätzlich den Turing-Test entwickelt, um
künstliche Intelligenz zu testen. Dieser Test beinhaltet Fragen, die ein Programm so
beantworten können muss, dass dessen Antworten nicht von möglichen Antworten
eines Menschen unterschieden werden können (vgl. [Kin96] S. 73ff, [Ada98] S. 22ff,
[Mai03] S. 9, 34ff, 87f, [Thr94] S. 12).
John von Neumann, dessen Rechnerarchitektur bis heute in den meisten Computern eingesetzt wird, hat gezeigt, dass es möglich ist, einen Automaten zu konstruieren, der alle Informationen enthält, sich selbst zu replizieren (klonen) (vgl.
[Kin96] S. 76ff, [Ada98] S. 23ff, [Thr94] S. 40ff).
Während der Entstehung dieser Arbeit ist es Forschern vom MIT gelungen,
Roboter zu entwickeln, die sich ganz nach der Vorstellung von Neumanns selbst
replizieren können. Sie bedienten sich der Eigenschaft der DNA, nahezu unbegrenzte Kopien von sich zu erzeugen. Realisiert wurden diese Roboter mit verschieden
farbigen Bauklötzen, die sich auf einem speziellen Luftkissentisch fortbewegen. Die
Bauklötze sind in der Lage andere Bauklötze, die sich auf dem Tisch befinden, zu
erkennen, deren Farbe festzustellen und sich mit ihnen zu verbinden, sofern dies
im Bauplan vorgesehen ist (vgl. [Eid05]).
Von Neumann war es auch, der die ersten Versuche mit zellulären Automaten
durchgeführt hat. Bekannt wurden diese allerdings erst durch das Game of Life“
”
von John Conway, das später vorgestellt wird.
Der Begriff künstliches Leben“ wurde 1987 auf der ersten Konferenz für künst”
liches Leben von Christopher G. Langton geprägt. Auf dieser Konferenz trafen sich
rund 160 Wissenschaftler aus den Bereichen Informatik, Biologie, Anthropologie,
Verhaltensforschung, Physik und anderen Gebieten, um die Simulation von Leben
im Computer und die damit verbunden Möglichkeiten zu diskutieren (vgl. [Kin96]
S. 123, [Thr94] S. xi).
3.4 Formen künstlichen Lebens
11
3.4 Formen künstlichen Lebens
Mittlerweile gibt es so viele Varianten künstlichen Lebens, dass eine grobe Einteilung, wie sie in diesem Kapitel gemacht wird, ihnen nur schwer gerecht werden
kann. Um aber einen kleinen Überblick über all die Möglichkeiten und Ideen zu
geben, die bisher genutzt wurden, um Leben“ im Computer zu erschaffen, wurden
”
einige dieser Konzepte auf Grund ähnlicher Ergebnisse, andere auf Grund ähnlicher
Verfahren zusammengefasst.
3.4.1 Zelluläre Automaten
Lebewesen bestehen aus einer oder mehreren Zellen, die durch eine Art Arbeitsteilung voneinander abhängig sind. Diesem Aspekt hat sich John von Neumann als
erstes angenommen, indem er 80 endliche Automaten mit den zwei Zuständen tot
(0) oder lebend (1) hintereinander geschaltet und diese mit drei einfachen Regeln
versehen hat:
1. Sind beide Nachbarn tot, ändere deinen Zustand nicht.
2. Lebt ein Nachbar und ist der andere tot, gehe in den Zustand lebend“.
”
3. Leben beide Nachbarn, verändere deinen Zustand (also von lebend“ in tot“
”
”
und umgekehrt).
Anstatt nun die Zahlen 0 und 1 zu verwenden, können die Zustände der Zellen auch grafisch dargestellt werden, indem tote Zellen durch ein Leersymbol und
lebende durch ein ausgefülltes Feld gezeichnet werden. Werden nun die einzelnen
Systemzustände in einer Art Zeitreihe untereinander dargestellt, entstehen verschiedenste Muster, die von Stephen Wolfram erstmals in unterschiedliche Klassen
eingeteilt wurden:
•
•
•
•
triviale Muster, z.B. nur tote oder nur lebende Zellen,
periodisch wiederkehrende Muster,
chaotische Muster und
Muster bestehend aus getrennten Teilen.
Einige Beispiele periodisch wiederkehrender Muster werden in Abbildung 3.1 gezeigt.
Abbildung 3.2 zeigt das wohl bekannteste Muster, das Stephen Wolfram entdeckt hat.
John Conway machte dieses Verfahren Ende der 1960er populär. Er entwickelte einen zweidimensionalen, schachbrettartigen Zellularautomaten. Diesen nannte
er Game of Life“, Spiel des Lebens. Im Unterschied zu den bisherigen Ansätzen
”
stellte Conway seine Zellen in den Folgeschritten nicht untereinander dar, sondern veränderte die Zellen direkt im Gitternetz. Dadurch haben sich erneut viele
verschiedene Muster herauskristallisiert:
• statische Muster,
• oszillierende Objekte,
• Gleiter,
3.4 Formen künstlichen Lebens
12
Abbildung 3.1. Beispiele verschiedener Klassen (Quelle: [Wol02] S. 284)
Abbildung 3.2. Rekursives Muster (Quelle: [Wol02] S. 263)
Abbildung 3.3. Beispielabfolge eines Life-Spiels
• uvm.
Diese Art des Zellularautomaten wurde sehr häufig nachgebildet, teilweise auch
mit mehr als nur zwei Zellzuständen. Der Einsatz von Zellularautomaten geht
sogar über das Feld der Informatik hinaus und wurde schon in den Wirtschaftswissenschaften eingesetzt, um wirtschaftliche Entwicklungen u.ä. zu simulieren. Ed
Frankin vom MIT - Dougles Adams lässt grüssen - sieht sogar die Welt selbst als
einen großen zellulären Automaten (vgl. [Kin96] S. 76ff, [Ada98] S. 22ff, [Mai03]
S. 94ff, [Thr94] S. 40ff).
3.4 Formen künstlichen Lebens
13
Den Gedanken von Neumanns, eines sich selbst reproduzierenden Automaten,
konnte dann Chris Langton mit seiner selbst reproduzierenden Schleife realisieren.
Langton gelang es, eine Struktur zu entwerfen, die sich bei einem entsprechenden
Regelsystem komplett selbst reproduziert. Dieser Zellularautomat besteht aus 8
Zuständen und 179 Regeln. Hier ist besonders interessant, dass Langton eine Art
Aussenhülle definiert hat, die durchaus mit der Hülle verglichen werden kann, die
sich um die Erbinformationen im Zellkern schließt (vgl. [Ada98] S. 39ff, [Mai03]
S. 97f, [Thr94] S. 65ff). Abbildung 3.4 zeigt den Aufbau der Schleife in ihrem
Startzustand und die nachfolgenden Schritte. Bei den ersten Schritten werden fast
alle Zustände abgebildet, bis die erste Reproduktion erreicht ist, am Ende des
Bildes sind spätere Zustände dargestellt.
Abbildung 3.4. Langtons Schleife
3.4.2 Biomorphe und L-Systems
Ein erster Ansatz, die Gestalt von Lebewesen“ zu bestimmen, wurde vom Wissen”
schaftler und Schriftsteller Richard Dawkins gemacht. Seine sogenannten Biomorphe sind Strukturen aus sich selbst reproduzierenden und von Genen gesteuerten
Elementen.
Hierbei setzt er auf ein einfaches geometrisches Muster: einen Stamm und zwei
Äste. Im Falle einer Reproduktion wird eine Kopie dieser Struktur an das Ende eines jeden Astes angehängt. Durch genetische Veränderung der Länge des Stammes
oder der Äste sowie dem Winkel des Stammes zur Horizontalen bzw. dem Winkel
zwischen den Ästen ergeben sich viele unterschiedliche Formen und Figuren (vgl.
[Kin96] S. 86ff, [Thr94] S. 59ff).
Abbildung 3.5. Beispiele für Biomorphe
Aristid Lindenmayer entwarf mit Hilfe der Grammatiktheorie von Noam Chomsky die nach ihm benannten L-Systems. Diese werden durch einfache Ersetzungsregeln beschrieben, z.B.:
3.4 Formen künstlichen Lebens
14
1 −→ 2, 32 −→ 4, 13 −→ 1, 14 −→ 2
Die verwendeten Zeichen können nun durch unterschiedliche Symbole ersetzt werden, woraus nach Einsatz der oben benannten Regeln Figuren entstehen, die häufig
an filigrane Strukturen aus der Natur erinnern. Abbildung 3.6 zeigt zwei noch recht
einfache Gebilde, die stark an Pflanzen erinnern. Es gibt aber noch viele weitaus
imposantere Ergebnisse1 , z.B. unter Verwendung von 3D Grafiken (vgl. [Kin96] S.
88ff, [Thr94] S. 124ff).
Abbildung 3.6. Beispiele für L-Systems
Die Beispiele der Biomorphe und L-Systems zeigen, dass ähnliche Ergebnisse auf
vollkommen unterschiedlichen Technologien basieren können. Während Dawkins
auf die Genetik setzt, findet sich bei Lindenmayer der Einsatz der ChomskyGrammatiken.
3.4.3 tierra, avida, amoeba
Das beeindruckenste Ergebnis im Bereich KL erzielte der Ökologe und Biowissenschaftler Thomas Ray von der Universität Delaware mit seiner tierra-Welt, die der
eigentlichen Evolution bisher wohl am nächsten kommt. Die Idee zu diesem Projekt
bekam Ray durch das Spiel Core Wars, in dem Programme um den Speicherplatz
einer virtuellen CPU kämpfen. Auf der Grundlage des Befehlssatzes dieses Spiels
entwickelte Steen Rasmussen Coreworld, mit dem er sich das Auftauchen selbstreproduzierender Programme erhoffte. Er setzte dabei auf die genetische Veränderung der Argumente der einzelnen Befehle. Dieses Projekt inspirierte Ray dazu,
tierra zu entwickeln.
Ray entwarf eine virtuelle CPU mit einem Befehlssatz von 32 Anweisungen.
Diese Sprache nannte er tierra (span. Erde). In tierra steht ein Programm für
ein Individuum. Die ersten selbstreplizierenden Individuen, die in die von ihm
genannte Ursuppe geworfen wurden, entwickelte Ray per Hand. Diese hatten eine
Länge von 80 Befehlen. Ray ging davon aus, dass das kürzeste selbstreplizierende
Programm mindestens 60 Befehle benötigt. Im Verlauf der tierra-Simulation haben
1
L-System von Norbert Klem: http://www.irtc.org/ftp/pub/stills/2001-06-30/warm up.jpg
3.4 Formen künstlichen Lebens
15
Programme bzw. Individuen die Möglichkeit, sich selbst zu replizieren, um damit
Nachkommen zu schaffen. Durch Mutationen können diese Programme zusätzlich
verändert werden. Anders als in einer normalen CPU sterben“ die Programme
”
nach einiger Zeit und werden dann aus dem Speicher gelöscht.
Rays Vermutung, ein Programm benötigt mindestens 60 Befehle, um sich weiterhin selbst zu kopieren, wurde von tierra widerlegt. Die Simulation hat Programme
mit 45 oder sogar 22 Befehlen hervorgebracht, die sich trotzdem über einen längeren Zeitraum behaupten konnten. Wie war dies möglich? Im Laufe einer Simulation
haben sich Parasiten und sogar Hyper-Parasiten gebildet, die den Code von grösseren Programmen kopiert haben und damit selbst Platz sparen konnten.
Wie im richtigen Leben hat Ray auf eine Fitnessfunktion verzichtet. Für ihn ist
das Überleben selbst der wichtigste Indikator für eine hohe Fitness.
Rays Ergebnisse wurden von vielen mit Erstaunen aufgenommen und haben
zum Weiterforschen ermutigt. Nennenswerte Abkömmlinge sind avida und amoeba. Die Entwickler von amoeba haben sich z.B. zum Ziel gesetzt, den Beginn des
Lebens zu simulieren. Sie wollten, dass sich ein selbstreproduzierendes Programm
zufällig und ohne ihr Zutun entwickelt. Um das Erreichen dieses Ziels wahrscheinlicher zu machen, wurde der Befehlssatz von amoeba auf 16 Befehle reduziert, wobei
fünf für ein selbstreproduzierendes Programm ausreichen. Und tatsächlich haben
sich im Laufe der Zeit Programme entwickelt, die in der Lage sind, sich selbst zu
reproduzieren (vgl. [Ada98] S. 42ff, [Thr94] S. 106ff).
3.4.4 Animate
Die verbreitetste Form künstlichen Lebens und wohl auch die Form mit den meisten
verschiedenen Ausprägungen sind die Animate. Der Name hat seinen Ursprung in
der Simulation von Tieren oder allgemein gesprochen komplexen Lebewesen. Er
lässt sich aus den englischen Wörtern Animal (Tier) und Automat bilden. Mit
Hilfe von Animaten lassen sich Eigenschaften von Lebewesen in vielerlei Hinsicht
simulieren und untersuchen. Hierzu zählen:
•
•
•
•
neural-motorische Fähigkeiten
Schwarmverhalten
Biosoziologische Phänomene
...
Einer der ersten bekannteren Animate ist John Hollands Frosch. Hierbei handelt
es sich um eine Rechnersimulation eines Frosches, der zwei grundlegende Eigenschaften besitzt: fressen und vermeiden, selbst gefressen zu werden. Hauptaufgabe
dieses Frosches ist es, Objekte, die in sein Blickfeld geraten, zu klassifizieren. Je
nach Größe, Abstand, Geschwindigkeit und Bewegungsart, sei es fliegend, kriechend usw., muss der Frosch entscheiden, ob er zuschlägt, um seine Nahrung zu
sichern, oder ob er flieht und sich versteckt, um nicht einem größeren Tier zum
Opfer zu fallen. Holland verwendete hierzu den von ihm entwickelten genetischen
Algorithmus, um die Verhaltensregeln des Frosches zu entwickeln (vgl. [Kin96] S.
42, [Thr94] S. 74f).
3.4 Formen künstlichen Lebens
16
Craig Reynolds Boids (Bird-oids) sollen Vögel mit Hilfe von Zellularautomaten
simulieren. Dabei werden den Automaten einige Grundregeln übergeben:
1. Jeder Vogel versucht, im Zentrum des Schwarms zu bleiben.
2. Jeder Vogel hält zu seinen Nachbarn einen Mindestabstand ein.
3. Richtung und Geschwindigkeit passt jeder Vogel an die Richtung und Geschwindigkeit des Nachbarn an.
Zusätzlich benötigen die Boids noch einige Zusatzregeln, die zum Ausweichen von
Hindernissen benötigt werden. Bei obiger Beschreibung wird deutlich, dass Boids
zur Simulation und Untersuchung von Schwarmverhalten eingesetzt werden. In
Abbildung 3.7 wird ein Boid-Schwarm dargestellt, der durch ein paar Hindernisse
fliegt. Die Simulation von Reynolds war sogar so realistisch, dass sein System im
Zeichentrickfilm Batman Returns“ verwendet wurde (vgl. [Kin96] S. 88f, [Thr94]
”
S. 121ff).
Abbildung 3.7. Boid-Schwarm beim Umfliegen von Hindernissen
Ein weiteres großes Feld im Bereich der Animate stellt die Simulation von Ameisenkolonien dar. Hier war es Chris Langton, der mit seinen Vants (Virtual Ants)
untersucht hat, wie das Verhalten eines Tieres in einer Kolonie das Verhalten der
anderen Tiere beeinflussen kann. In dieser Simulation bewegen sich die virtuellen Ameisen auf einem schachbrettartigen Feld. Sowohl Felder als auch Ameisen
nehmen verschiedene Zustände, beschrieben durch Farben, an. Die Bewegungen
einer Vant sind abhängig vom eigenen Zustand und von dem des Feldes, auf dem
sie steht. Entsprechend werden auch die Folgezustände geändert. Die jeweiligen
Zustände, Zustandsänderungen und Bewegungen werden in der folgenden Tabelle
(Tabelle 3.1) beschrieben (vgl. [Kin96] S. 97ff, [Thr94] S. 118ff).
Zustand Vant Zustand Feld Aktion nachher Zustand Feld nachher
rot
grün
Linksdrehung
schwarz
rot
schwarz
Rechtsdrehung
grün
blau
grün
Rechtsdrehung
schwarz
blau
schwarz
Linksdrehung
grün
Tabelle 3.1. Verhaltensmuster von Langtons Vants (vgl. [Kin96] S. 98)
Neben diesen eher abstrakten Simulationen gibt es auch zahlreiche Beispiele,
die sich vor allem auf die Evolution der Anatomie konzentrieren. Zu den herausragendsten Arbeiten in dieser Richtung gehören die Kreaturen von Karl Sims, die
3.5 Verwandte Arbeiten
17
zudem einen großen inspirativen Einfluss auf diese Arbeit haben. Hierzu aber mehr
im Kapitel Verwandte Projekte“.
”
Durch das ständige Anwachsen der Leistungen von Computern sind vor allem
auf dem Spielesektor die Ansprüche enorm gestiegen. Neben immer realistischeren
Grafiken verlangt die Spielergemeinde immer intelligentere Computergegner, mit
denen sie sich messen kann. Dadurch werden viele KL-Technologien in der Spieleentwicklung eingesetzt. Aber auch Animate finden in diesem Umfeld eine Nische.
Beispiele hierbei sind der virtuelle Fishtank von Nearlife, der seinen Platz im Museum of Science in Boston gefunden hat oder das Spiel Creatures, das mittlerweile
in den Händen von Gameware Development liegt. Creatures kann mit einem überdimensionalen Tamagotschi verglichen werden. Der Spieler hat die Aufgabe, kleine
Kreaturen, Norns genannt, zu züchten und ihnen beizubringen, in ihrer Umwelt zu
überleben. Norns sind stark triebgesteuert und reagieren entsprechend ihrer Stimmungslage, ihrem Hunger oder Durst oder ihrer Langeweile immer anders. Durch
Belobigung oder Bestrafung kann der Spieler Norns erziehen, indem er ihnen ein
direktes Feedback auf ihre Handlungen gibt. Neben dem Lernen besitzen Norns ein
ausgeklügeltes Biosystem, das z.B. durch Krankheiten oder Gifteinnahme beeinflusst werden kann. Zu guter Letzt sind diese kleinen, aufgeweckten Wesen in der
Lage, sich untereinander fortzupflanzen, um ihre Gene und damit ihre Eigenschaften weiterzugeben. Bei den Nachkommen wird dies am auffälligsten in Fellfarbe
und -muster deutlich. Ähnlich wie Thomas Rays tierra könnte Creatures immer
weiter gespielt werden. Hauptziel des Spielers sollte eine sich selbst erhaltende Population von Norns sein, die in der Lage ist, auf die Gefahren ihrer Umwelt Acht zu
geben, die Möglichkeiten, die sie in ihrer Umwelt bekommt, zu nutzen und Wissen
und ihre Erfahrung an ihre Nachkommen weitergeben können.
3.4.5 Von Viren und Würmern
Im Vergleich zu den Norns oder Lindenmayers L-Systems sind Computerviren
alles andere als amüsant. Trotz allem müssen sie in die Reihe der künstlichen
Lebewesen aufgenommen werden. In der Biologie werden sie oft nur als beinahe
lebendig eingestuft, in der Welt der künstlichen Lebewesen sind sie auf Grund ihrer
Eigenschaft, sich selbst zu reproduzieren, einer der ältesten Vertreter. Mittlerweile
gibt es sogar viele wissenschaftliche Arbeiten über diese lästigen Parasiten.
Aber auch wegen der grossartigen Ergebnisse, die Thomas Ray machte, seine
Parasiten zählen schließlich auch zu den Viren, sollte man diese Spezies nicht ausser
Acht lassen (vgl. [Thr94] S. 24f).
3.5 Verwandte Arbeiten
In diesem Abschnitt werden Arbeiten vorgestellt, die zu dieser Arbeit inspiriert
haben oder die ähnliche Ziele verfolgen.
3.5 Verwandte Arbeiten
18
3.5.1 Karl Sims virtuelle Kreaturen
Der erste, der sich Gedanken über die Entwicklung der Morphologie von Lebewesen
im dreidimensionalen Raum gemacht hat, war Karl Sims [Sim94b]. Seine Ergebnisse auf diesem Gebiet, die er 1994 auf der SIGGRAPH Konferenz vorgestellt hat,
sind bis heute noch unerreicht.
Seine Kreaturen haben mit Hilfe eines genetischen Algorithmus ihren Körperbau
entwickelt und zusätzlich gelernt, sich entsprechend fortzubewegen. Sims hat den
Kreaturen mehrere Aufgaben gegeben, die sie erreichen sollten. Darunter fallen:
•
•
•
•
•
Laufen,
Springen,
Schwimmen,
Verfolgen eines beweglichen Punktes und
Bestehen in einem Wettkampf gegen andere Kreaturen.
Die Morphologie seiner Kreaturen wurden durch gerichtete Graphen beschrieben. Ein Knoten eines solchen Graphen steht für ein Körperteil, eine Kante für ein
Gelenk zwischen zwei Körperteilen. Abbildung 3.8 zeigt verschiedene Beispielgraphen und der daraus resultierenden Anatomie der Kreaturen.
Abbildung 3.8. Beispielgraphen und die daraus entstehende Morphologie. (Quelle: [Sim94b] S. 2)
3.5 Verwandte Arbeiten
19
Die Bewegung erfolgt über Effektoren, die vom Gehirn“ einer Kreatur ange”
steuert werden. Effektoren sind vergleichbar mit Muskeln, die Gelenke bewegen.
Als Eingabe bekommt das Gehirn einer Kreatur diverse Sensordaten, die ihm Auskunft über Gelenkwinkel, Bodenberührung oder Lichtveränderungen geben. Die
Berechnung der Effektordaten geschieht über sogenannte Neuronen, die verschiedene mathematische Operationen auf den Sensordaten ausführen. Obwohl Sims
von Neuronen spricht, ist diese Methode eher mit genetischer Programmierung als
mit künstlichen neuronalen Netzen vergleichbar.
Eines der interessantesten Experimente, die Sims mit seinen Kreaturen gemacht
hat, war ein Wettkampf um einen Block. Dabei hat die Kreatur gewonnen, die die
längste Zeit den Block berührt hat bzw. die einen größeren Teil des Blocks berührt
hat. Die Ziele des Wettkampf werden durch Abbildung 3.9 verdeutlicht.
Abbildung 3.9. Beispiele sich bekämpfender Kreaturen (Quelle: [Sim94a] S. 37)
3.5.2 Gene Ruebsamens embodied agents
Gene Ruebsamen [Rue04] wurde ebenfalls von Karl Sims Ergebnissen beeindruckt
und verfolgte einen ähnlichen Ansatz. Doch anstatt, wie Sims, die physikalische Simulation selbst zu implementieren, verwendet Ruebsamen die C-Bibliothek ODE,
die auch in dieser Arbeit eingesetzt wird.
Ein weiterer wesentlicher Unterschied zu Sims ist, dass sich Ruebsamen nur
auf das Verhalten seiner von ihm benannten embodied agents konzentrierte, den
Körperbau definierte er jeweils per Hand. Statt auf eine einfache Neuronenstruktur
mit unterschiedlichen mathematischen Formeln zu setzen, probierte er sein Glück
mit der noch relativ neuen Methode der neuronalen Evolution. Darunter versteht
man die Verbesserung neuronaler Netze mit Hilfe eines genetischen Algorithmus,
wobei die Gewichte als Gene verstanden werden, die untereinander ausgetauscht
(Crossover) oder deren Wert verändert wird (Mutation). Auch Ruebsamen setzte
dabei auf das Konzept von Sensoren und Effektoren, um Eingabe und Ausgabe zu
steuern.
Im Gegensatz zu Sims beließ es Ruebsamen bei einer einzigen Aufgabe, die seine
embodied agents erfüllen mussten. Sie sollten sich lediglich möglichst schnell und
weit auf der x-Achse fortbewegen.
3.5 Verwandte Arbeiten
20
3.5.3 Sigel
Ein ganz anderes Ziel verfolgt das Sigel-Projekt der Universität Dortmund. Sigel
steht für Simulator für GP-evoluierte Laufrobotersteuerungen. Dabei handelt es
sich um einen Robotersimulator, der nach Angabe des Aufbaus eines Laufroboters
einen möglichst effizienten Bewegungsablauf entwickeln soll.
Ähnlich wie Sims und Ruebsamen wird hier auf das Konzept der Sensoren und
Effektoren zurück gegriffen. Der grösste Unterschied besteht erneut in der Verarbeitung dieser Daten. Sigel setzt hierfür eine Art Assembler ein, dessen Registerinhalte dann mit Hilfe genetischer Programmierung angepasst und entwickelt werden
sollen (vgl. [MCV01]). In Abbildung 3.10 wird die Simulation eines dreibeinigen
Roboters dargestellt.
Abbildung 3.10. Bewegungsablauf eines Dreibeiners (Quelle: [MCV01] S. 178)
3.5.4 Marbachs modulare Roboter
Daniel Marbach [Mar05] hat in seiner Masterarbeit auf der école polytechnique
fédérale de Lausanne eine Verbindung zwischen der Arbeit von Sims und dem
Sigel-Projekt geschaffen. Er fixiert sich nicht nur auf die Bewegung von Robotern,
sondern ist auch überzeugt von der Wirkungskraft der Evolution bezüglich des
Aufbaus von Robotern.
Ähnlich wie das Sigel-Projekt arbeitet Marbach auf einer Simulation der Roboter, die er mit der ODE-Bibliothek realisiert hat, um sich die Implementierung
der physikalischen Simulation zu ersparen. Die simulierten Roboter setzen sich aus
unterschiedlichen Bauteilen zusammen, die miteinander verknüpft werden können.
Dieser Vorgang ist mit Legosteinen vergleichbar, die den Bau unterschiedlichster
Formen begünstigen.
Um die Kombination der unterschiedlichen Bauteile und deren genetische Entwicklung zu beschreiben, verwendet Marbach Lindenmayers L-Systems. Die Bewegungen werden schließlich über genetische Programmierung erlernt. Abbildung 3.11
zeigt die Simulation eines hieraus entstanden Roboters. In dieser Abbildung sind
vor allem die einzelnen Bauteile eines solchen Roboters deutlich zu erkennen.
3.5 Verwandte Arbeiten
Abbildung 3.11. Beispiel eines generierten Roboters (Quelle: [Mar05] S. 71)
21
4
Der Genetische Algorithmus
In vielen Fällen kann die Wissenschaft auf Konzepte zurückgreifen, die ihr die
Natur vorgelebt hat. So werden Methoden oder Phänomene der Natur zumindest
abstrakt in der Technik umgesetzt. Flugzeuge imitieren z.B. die aerodynamische
Form der Vogelflügel, ohne jedoch die eigentliche Flugtechnik nachzubilden. Aber
auch in der Informatik werden Konzepte der Natur aufgegriffen, um Probleme
besser lösen zu können. Die Genetik ist da nur eines von vielen Beispielen (vgl.
[IG04] S. 33).
4.1 Genetik in der Natur
4.1.1 Geschichte der Genetik
Evolutionäre oder Genetische Algorithmen (kurz EA bzw. GA) greifen auf die
von Charles Darwin (1809 - 1882) erarbeitete Evolutionstheorie zurück. Hauptbestandteil dieser Theorie ist die in der Natur auftretende Fähigkeit, sich an eine
verändernde Umwelt anzupassen. Dabei spielt das von Darwin beschriebene Naturgesetz Überleben des Stärkeren“ (survival of the fittest) eine wesentliche Rolle.
”
Zur selben Zeit wie Darwin lebte Gregor Mendel (1822 - 1884), ein Augustinerabt, der Versuche mit Erbsenpflanzen anstellte, indem er sie, abhängig von ihrer
Blütenfarbe kreuzte. Aus den daraus entstandenen Nachkommen leitete er die nach
ihm benannten Mendelschen Regeln ab. Mit der Arbeit Mendels ist die klassische
Genetik entstanden.
In der heutigen Zeit wird vor allem in der Molekulargenetik geforscht, die sich
mit dem Aufbau der Gene beschäftigen und die im nächsten Abschnitt kurz vorgestellt werden soll (vgl. [IG04] S. 217ff, [HB89] S. 332ff).
4.1.2 Aufbau und Arbeitsweise von Genen
Das Geheimnis der Evolution findet sich im Mikrokosmos der Zellen. Es werden
zwei Arten von Zellen unterschieden:
• prokaryotische Zellen, die keinen Zellkern (Nukleus) besitzen und
• eukaryotische Zellen, die eben einen solchen Zellkern beinhalten.
4.1 Genetik in der Natur
23
Eukaryotische Zellen bilden die Mehrheit im Zellvorkommen eines Lebewesens und
beherbergen im Innern des Zellkerns die Träger der Erbinformationen, die Chromosomen.
Jede Spezies besitzt eine feste Anzahl Chromosomen. Der Mensch hat z.B. 46,
wobei die Anzahl der Chromosomen nichts über die Komplexität eines Lebewesens
aussagt. Schimpansen und Kartoffeln besitzen jeweils 48 Chromosomen, ein Karpfen sogar 104, wohingegen Mais mit nur 20 Chromosomen auskommt (vgl. [IG04]
S. 218).
Aber die eigentlichen Erbinformationen liegen in den Genen, die in den Chromosomen enthalten sind. Gene beschreiben eine bestimmte Eigenschaft des Lebewesens, Allel genannt. Ein typisches Beispiel ist die Augenfarbe eines Menschen
(z.B. grün, blau oder braun). Dabei wird zwischen dominanten und rezessiven
Ausprägungen unterschieden. Dieses Phänomen ist allerdings nur durch die doppelte Anzahl jedes Chromosoms (diploide Chromosomen) gegeben. Jeder Elternteil
steuert dabei die Hälfte der Chromosomen bei. Erbt z.B. ein Kind vom Vater ein
Chromosom mit der Ausprägung blaue Augen“ und von der Mutter ein Chromo”
som, das das Allel für braune Augen“ trägt, so setzen sich die braunen Augen
”
als dominantes Allel durch, was dem Kind braune Augen beschert. Durch das diploide Auftreten eines Chromosoms gehen die Informationen des rezessiven Allels
zunächst nicht verloren, sondern können in späteren Generationen wieder auftreten
(vgl. [IG04] S. 218).
Abbildung 4.1 zeigt einen Erbgang mit zwei Merkmalen von Kühen. Das erste
Merkmal beschreibt die Fellfarbe der jeweiligen Kuh, wobei das schwarze Fell dominanter ist als das braune Fell. Die zweite Merkmalsausprägung ist das Fellmuster,
wobei der Besitz eines Musters als rezessives Allel erkennbar ist.
Doch auf welche Weise speichern die Gene diese Informationen und wie können
sie wieder ausgelesen werden? Um diese Fragen zu beantworten, muss die chemische
Zusammensetzung der Gene erläutert werden.
Die Motoren für Stoffwechselvorgänge im Körper sind die Enzyme. Diese wiederum sind Proteine, Makromoleküle aus ein oder mehreren Polypeptidketten, die
sich aus Aminosäuren zusammensetzen. Ein Lebewesen besitzt hierzu in der Regel
20 Aminosäuren. Damit liegt die Aufgabe der Gene in der Festlegung der Reihenfolge der Aminosäuren.
Die eigentlichen Träger der Gene sind die Nukleinsäuren. Bekanntester Vertreter ist die Desoxyribonukleinsäure (DNS, engl. DNA). In den Nukleinsäuren
sind 4 Basen vorhanden, mit denen Proteine codiert werden können. In der DNS
handelt es sich um die Basen Guanin, Adenin, Thymin und Cytosin. Die bekannte Doppelhelix-Struktur ergibt sich aus einem stickstoffhaltigen Ring aus einem
Zucker und Phosphorsäure und der paarweisen Verbindung der Basen. Nach dem
verwendeten Zuckerbaustein wird die Nukleinsäure benannt. Die Ribonukleinsäure
(RNA) benutzt die Ribose, die DNS die Desoxyribose. Jeweils zwei der vier Basen
sind in der Lage, sich mittels Wasserstoffbrücken zu verbinden, Adenin mit Thymin
und Cytosin mit Guanin. Dadurch entsteht bei der DNS die typische DoppelhelixStruktur (siehe Abbildung 4.2). Die gegenüberstehenden Stranghälften beschreiben
so das Negativ ihres Gegenüber (vgl. [HB89] S. 355ff).
4.1 Genetik in der Natur
24
Abbildung 4.1. Erbgang mit zwei Merkmalen (dihybrider Erbgang) (Quelle:
[HB89] S. 355)
Chromosomen entstehen dadurch, dass sich ein DNS-Strang um Proteinpartikel
windet. Dadurch entsteht eine stabilere Struktur, die in Abbildung 4.3 dargestellt
wird.
Weil die DNS 20 Aminosäuren mit nur 4 Basen codieren muss, wird jeweils ein
Triplett, eine Kombination dreier aufeinanderfolgender Basen, als Codierung verwendet. Mit den damit entstehenden 43 = 64 Codewörtern können folglich alle 20
Aminosäuren codiert werden. Die überschüssigen Codewörter werden entweder zur
Mehrfachcodierung von Aminosäuren verwendet oder sie stehen für verschiedene
4.1 Genetik in der Natur
25
Abbildung 4.2. Aufbau der DNS (i.A.a. [HB89] S. 357)
Abbildung 4.3. Chromosomenfeinstruktur
Steuerzeichen. Unter den Begriff Steuerzeichen fallen Start- oder Stop-Codons, die
den Anfang oder das Ende eines Codewortes anzeigen. Interessant ist die Tatsache,
dass der genetische Code universell gilt, d.h. jedes Lebewesen verwendet die gleiche
Codierung der einzelnen Proteine (vgl. [HB89] S. 355ff, [IG04] S. 217ff).
Gerade im genetischen Code lassen sich viele Parallelen zur Informatik ziehen.
Ist doch ein Computerprogramm nichts anderes als eine Kette von Wörtern und
Steuerzeichen. Die Kommunikation in Computernetzwerken bedient sich ebenfalls
4.1 Genetik in der Natur
26
mehrerer Steuerbefehle und Verfahren Codierfehler vorzubeugen, was sich durch
nahezu alle Schichten des OSI-Referenzmodells zieht. Aber auch die Codierung ist
interessant, findet man doch in der Informatik häufig ein Alphabet, das sogar aus
nur zwei Zeichen codiert wird: 0“ und 1“ (vgl. [GC02] S. 101ff).
”
”
4.1.3 Evolution
Die Evolution beschreibt die stammesgeschichtliche Entwicklung von Lebewesen,
deren Adaption an ihre Umwelt und die Entstehung neuer Arten. Doch wie kommt
es zu diesen Anpassungen oder Änderungen, dass sie sogar neue Arten hervorbringen? Ein wichtiger Faktor der Evolution ist die Selektion. Sie steht in enger
Verbindung mit der Theorie von Charles Darwin, dass nur die Stärkeren überleben.
Die gängigste Form der natürlichen Auslese ist die Fortpflanzung, da sich dabei
zwei verschiedene Chromosomensätze miteinander kombinieren und zu einem neuen zusammenfügen. Werden dadurch Eigenschaften vererbt, die einem Lebewesen
einen Vorteil gegenüber seinen Artgenossen verschaffen, ist dieses eher in der Lage
sich gegen Konkurenten durchzusetzen und sich weiter fortzupflanzen.
Eine eher durch den Zufall geprägte Form ist die Mutation, oft hervorgerufen durch radioaktive Strahlung, UV-Licht oder Chemikalien. Zum einen kann es
zu Veränderungen der Chromosomen kommen. Dabei werden mehrere Arten von
Änderungen oder Eingriffen unterschieden: Die Deletion bezeichnet den Verlust
eines Chromosomenteils, was in den meisten Fällen den Tod für das betroffene
Lebewesen bedeutet. Bei Verlust des Endstücks spricht man von Defizienz. Treten
nach der Zellteilung Gene doppelt auf, so wird dies als Duplikation bezeichnet. Im
Falle der Inversion wird die Reihenfolge der Chromosomen zumindest teilweise vertauscht. Auch die Veränderung der Chromosomenzahl zählt zu den Mutationen.
Bekannt ist dieses Phänomen beim Menschen durch die Krankheit Trisomie 21,
auch Down-Syndrom oder Mongolismus genannt. Betroffene Menschen besitzen
ein zusätzliches 21. Chromosom (vgl. [IG04] S. 219ff, [HB89] S. 349, 398f).
Genmutationen, bei denen es zu Veränderungen der Codewörter auf dem DNSStrang kommen kann, sind ebenfalls möglich. Diese Änderungen müssen nicht
zwingend auffallen. Tritt die Mutation bei einem rezessiven Allel auf, wirkt sie
sich zunächst nicht auf das betroffene Lebewesen aus, sondern wird vielleicht erst
in späteren Erbgängen in Erscheinung treten oder vielleicht auch nie. Durch die
Mehrfachcodierung von Aminosäuren kann es vorkommen, dass zwar eine genotypische Veränderung auftritt, diese aber keinen Einfluss auf die phänotypischen
Ausprägungen des Lebewesens hat, da der mutierte Codeabschnitt zur gleichen
Transformation führt. Dies ist auch ein Grund, warum der Einfluss der Mutation
auf die Evolution noch bis heute umstritten ist und eher als evolutionshemmend
als -fördernd gesehen wird. Andererseits hat die Natur mit der Mutation einen Weg
gefunden, das Festfahren der Evolution in eine bestimmte Entwicklungsrichtung
zu verhindern (vgl. [IG04] S. 219ff).
Ein weiteres Phänomen wurde von Thomas Morgan (1866 - 1945) bei Versuchen mit der Fruchtfliege Drosophila endeckt. Er fand heraus, dass es während der
Meiose, einem Zustand der Zellteilung, bei der sich die Chromosomen paaren und
4.2 Genetik in der Informatik
27
umeinander schlingen, zu einem Bruch von Nicht-Schwesterchromatiden kommen
kann, wobei sich die abgetrennten Teile gegeneinander austauschen (siehe Abbildung 4.4). Bei der Spiralisierung der Chromosome bilden sich Chromomare, an
denen ein solcher Bruch entstehen soll. Dies sichert die Lebensfähigkeit des Lebewesens, das aus der neuen Kombination entsteht. Dieser Vorgang wird Crossingover bezeichnet. Anders als die Mutation führt das Crossing-over keine zufälligen
Änderungen durch, sondern wird von der Natur gezielt und bewusst eingesetzt, um
die Entwicklung voranzutreiben oder sie in eine andere Richtung zu lenken (vgl.
[IG04] S. 219ff, [HB89] S. 441).
A
u
s
t
a
u
s
c
h
u
s
u
s
t
a
u
s
c
h
A
u
s
t
a
u
s
c
h
crossing-over
Chromomar
A
A
t
a
u
s
c
h
Abbildung 4.4. Crossing-over mit Austausch gleicher Chromatiden-Abschnitte
(i.A.a. [HB89] S. 441)
4.2 Genetik in der Informatik
Wie schon in der Einleitung dieses Kapitels erwähnt, greift die Wissenschaft gern
auf Konzepte der Natur zurück. In der Informatik werden viele Konzepte der Genetik in den sogenannten Evolutionären Algorithmen aufgegriffen. Evolutionäre
Algorithmen umfassen Themen wie Evolutionsstrategien, Genetische Algorithmen
als auch deren Unterart, die Genetische Programmierung. Die Verfahren weisen im
Allgemeinen sehr viele Ähnlichkeiten auf. Eine Unterscheidung ist hauptsächlich
geschichtlich bedingt. Im Hinblick auf Evolutionäre Algorithmen können viele Begriffe aus der Genetik wiederverwendet werden, obwohl sie nicht unmittelbar mit
ihrem natürlich Vorbild übereinstimmen.
Der Genetische Algorithmus wurde in den 1970er Jahren von John Holland entwickelt. Er sieht die Entwicklung einer Population verschiedener Individuen über
mehrere Generationen hinweg vor. Dabei muss allerdings das Individuum mit dem
Begriff Chromosom gleichgestellt werden, da jedes Individuum nur ein Chromosom
besitzt. Ein solches Chromosom besteht aus einem String, der sich aus den Zeichen
0 und 1 zusammensetzt. Damit ist ein Gen ein Zeichen dieses Strings und sein Wert
bezeichnet eine Ausprägung bzw. ein Allel. Dieser Zeichenvektor kann folglich als
Genotyp bezeichnet werden, seine Interpretation letztendlich als Phänotyp (vgl.
[IG04] S. 34). Ein Beispiel eines solchen Chromosoms zeigt Abbildung 4.5.
Der eigentliche Algorithmus arbeitet mit einer Fitnessfunktion, die die Überlebenswahrscheinlichkeit eines jeden Indiviuums bestimmt. Je höher der Wert dieser
Funktion ist, desto besser ist das Individuum an seine Umwelt angepasst.
4.2 Genetik in der Informatik
Variable
28
x1
x2
x3
... 1 1 0 1 0 1 1 0 0 1 0 1 1 0 ...
Gen Allel
Abbildung 4.5. Zeichenstring
Die Umwelt eines Individuums in einem Genetischen Algorithmus muss hier
sehr abstrakt aufgefasst werden, da es sich um sehr unterschiedliche Ausprägungen handeln kann und vom jeweiligen Einsatzgebiet abhängt. Häufig werden genetische Algorithmen eingesetzt, um Probleme zu lösen, die in der Komplexitätstheorie behandelt werden und die auf herkömmliche Weise praktisch nicht lösbar sind.
Die Rede ist hier von den NP-vollständigen Problemen, wie zum Beispiel das des
Handlungsreisenden (Travelling Salesman Problem, TSP). In diesem Fall wäre ein
Individuum eine Route für den Handlungsreisenden. Die Fitness wäre die zurückgelegte Entfernung. Da es sich hierbei um ein Minimierungsproblem handelt, muss
die Fitness natürlich minimiert werden, d.h. das Individuum mit der geringsten
Wegstrecke scheint sich in seiner Umwelt“ am geeignetsten zu verhalten.
”
Die Aufgabe des Algorithmus besteht nun darin, über mehrere Generationen
hinweg immer bessere Individuen zu schaffen. In den meisten Fällen wird mit
einer zufälligen Population begonnen, aus der sich die späteren Generationen bilden. Dabei spielt die Selektion eine grosse Rolle. Sie sorgt für die Auswahl der
stärksten“ Individuen und sichert deren Fortbestand. Nachfolgende Generatio”
nen werden dann durch Rekombination oder Mutation dieser ausgewählten Eltern
erzeugt.
Die Rekombination wird bei den genetischen Algorithmen auch als crossover
bezeichnet. Zwei Individuen werden miteinander gekreuzt, um zwei Nachfolgeindividuen zu bilden. Dabei werden die Chromosomenstrings jeweils an der gleichen
Stelle getrennt und überkreuz ausgetauscht (siehe Abbildung 4.6). Beim cross-over
werden zwei unterschiedliche Konzepte der Natur zusammen geführt: Die Aufteilung der Erbinformationen zweier Individuen, wie sie bei der geschlechtlichen
Fortpflanzung geschieht, und das crossing-over-Phänomen, das ursprünglich nur
bei einem Lebewesen auftritt.
cross-over
Abbildung 4.6. Crossover (Quelle: [IG04] S. 40)
4.3 Fitnessfunktion
29
Mutation ist eine weitere Möglichkeit des genetischen Algorithmus, Nachkommen zu verändern, um eine bessere Lösung anzustreben oder ein lokales Optimum
zu überspringen. Bei diesem genetischen Operator werden einfach ein oder mehrere
Zeichen gekippt, d.h. aus einer 0 wird eine 1 und umgekehrt (siehe Abbildung 4.7).
Mutation
Abbildung 4.7. Mutation (Quelle: [IG04] S. 41)
Damit lässt sich ein Genetischer Algorithmus in folgende Schritte aufteilen:
1.
2.
3.
4.
Schaffen einer Startpopulation
Berechnung der Fitness
Selektion und
Anwendung der genetischen Operatoren (Rekombination, Mutation) zur Bildung der nächsten Generation.
Dieser Vorgang wird dann ab Schritt 2 entweder eine bestimmte Anzahl von Generationen lang oder bis zum Erreichen einer bestimmten Fitnessschwelle wiederholt.
Der Wunsch, den Genetischen Algorithmus stetig zu verbessern oder ihn an
unterschiedliche Problemstellungen anzupassen, hat viele Verfahren und Strategien hervorgebracht, um Fitness, Selektion oder genetische Operatoren effizienter zu
gestalten. Die folgenden Kapitel geben daher einen tieferen Einblick in die unterschiedlichen Ansätze und Ideen.
4.3 Fitnessfunktion
Die Überlebens- bzw. Vermehrungschancen jedes einzelnen Individuums werden
durch seine Fitness bestimmt. Diese wird durch die Fitnessfunktion berechnet.
Dabei gilt, je höher die Fitness, desto stärker das Chromosom. Wie später bei der
Untersuchung verschiedener Selektionsverfahren deutlich wird, ist es sinnvoll, den
Wertebereich der Fitnessfunktion auf R+ einzuschränken.
Werden genetische Algorithmen zur Lösung von Optimierungsproblemen eingesetzt, kann die Fitnessfunktion mit der Zielfunktion gleichgesetzt werden. Aber
in vielen anderen Bereichen ist dies nicht so einfach möglich, was zu verschiedenen Ansätzen geführt hat. Zur Berechnung der eigentlichen Fitness wird in jedem
nachfolgend erklärten Verfahren eine vorläufige Fitness f it∗ verwendet, die dann
weiter verfeinert wird (vgl. [IG04] S. 37f, 68f).
4.3.1 Lineare skalierte Fitness
Eine häufig angewandte Strategie bei der Definition der Fitnessfunktion ist der
Einsatz von Belohnung und Bestrafung der Chromosomen. Im Fall der linear ska-
4.3 Fitnessfunktion
30
lierten Fitness erfolgt die Belohnung durch die Konstante a ∈ R+ und die Bestrafung durch den Penalty-Faktor b ∈ R. Die lineare statische Skalierung errechnet
sich demnach wie folgt:
f it(c) = a ∗ f it∗ (c) + b
wobei der Faktor b kleiner als die eigentliche Fitness sein muss, was allerdings das
Wissen über das gesuchte Optimum vorraussetzt.
Deshalb wird statt der statischen die dynamische Variante der linearen Skalierung verwendet, bei der die kleinste gemessene Fitness einer Population P (t) statt
dem Faktor b zur Bestrafung“ verwendet wird.
”
f it(c, P (t)) = a ∗ f it∗ (c) − min{f it∗ (ci )|ci ∈ P (t)}
Durch diesen Schritt werden die Unterschiede der Fitness deutlicher hervorgehoben, was allerdings die Gefahr beinhaltet, ein Superindividuum zu erhalten, das
sich gegenüber allen anderen Chromosomen durchsetzt und was wiederum zu einer
vorzeitigen Konvergenz führt (vgl. [IG04] S. 69f).
4.3.2 σ-Skalierung
Die σ-Skalierung erweitert die lineare Skalierung um populationsabhängige Faktoren wie mittlere Fitness und Streuung. Hier werden der Faktor a ∈ R und die
Standardabweichung σ(P (t)) der Bewertung der Population verwendet:

∗
∗
∗

f it (c) − (f it − a ∗ σ(P (t)) falls f it (c) ≥
f it(c, P (t)) =
(f it∗ − a ∗ σ(P (t)))


0
sonst
Eine Variante dieses Verfahrens sieht folgende Berechnung vor:
(
f it∗ (c) + (f it∗ − a ∗ σ(P (t)) falls f it∗ ≥ a ∗ σ(P (t)))
f it(c, P (t)) =
0
sonst
Bei letzterer Variante werden die Populationen im Lauf der Zeit immer homogener, was zu einem niedrigeren Selektionsdruck führt, da schlechte Chromosomen
überhaupt nicht mehr am Auswahlprozess teilnehmen (vgl. [IG04] S. 70).
4.3.3 Exponentielle Skalierung
Die exponentielle Skalierung wurde 1985 von Gilles unter dem Namen Power
”
Scaling“ entwickelt und sieht folgende einfache Form vor:
f it(c) = (f it∗ (c))k mit k ∈ R
Unter Berücksichtigung einer Belohnung a ∈ R+ , einer Bestrafung b ∈ R und einer
Konstanten k ∈ R oder einer Abbildung k(t, s) : N × R → R ergeben sich zwei
Varianten:
4.3 Fitnessfunktion
31
• Exponentielle Skalierung:
f it(c) = (a ∗ f it∗ (c) + b)k
• Ungleichmäßig exponentielle Skalierung:
f it(c) = (a ∗ f it∗ (c) + b)k(t,s)
Dabei nimmt die Funktion k(t, s) Bezug auf das Populationsalter bzw. die Generation t und eine Spannweite s. Michalewicz, der diese Variante entwickelt hat,
definiert k wie folgt:
k(t, s0 ) =
s∗
s0
P1
∗ tan
t
π
∗
T +1 2
P2 ( ss∗0 )α
mit s∗ = 0.1, α = 0.1, P1 = 0.05, P2 = 0.1 und T = maximale Anzahl von
Generationen. Die Spannweite s0 wird aus dem Quotienten der Streuung der Bewertung der Anfangspopulation und der mittleren Bewertung aller Elemente der
Anfangspopulation berechnet (vgl. [IG04] S. 70ff).
4.3.4 Geteilte Fitness
Der Hintergrund dieser Strategie liegt in der Unterbindung der Ausbildung von
Superindividuen und damit einer vorzeitigen Konvergenz. Dieses Verfahren zählt
zu den Nischentechnologien, die sich das Vorbild der Natur zu Nutze machen, in
der sich Lebewesen einen Lebensraum teilen, indem sie Nischen ausbilden. Eine
ökologische Nische ist nicht zwingend ein räumlicher Begriff, sondern er beinhaltet
viel mehr als das, worunter unter anderem Ernährung, Art und Ort der Brutplätze
oder Tag- oder Nachtaktivität fallen.
Um eine solche Nische in einem genetischen Algorithmus zu erhalten, müssen
Chromosomen miteinander vergleichbar sein und verglichen werden. Liegen die
Chromosomen als binärer String vor, könnte die Hammingdistanz als Ähnlichkeitsmaß herangezogen werden. Das bedeutet, dass dieses Verfahren eine Abstandsgleichung d(c1 , c2 ) benötigt, die die Ähnlichkeit zweier Individuen bestimmt und eine
Sharing-Funktion Sh(d(c1 , c2 )), die diese Ähnlichkeit in das Intervall [0, 1] abbildet.
Dabei liegt der Wert der Sharing-Funktion umso höher, je größer die Ähnlichkeit
ist. Die Fitness eines Chromosoms wird dann wie folgt berechnet:
f it(c) =
f it∗ (c)
popsize
P
Sh(d(c, ci ))
i=1
Goldberg und Richardson haben folgende Form der Sharing-Funktion ausgearbeitet:
α
(
1 − d(cσ1Sh,c2 )
falls d(c1 , c2 ) < σSh
Sh(d(c1 , c2 )) =
0
sonst
4.3 Fitnessfunktion
32
α und σSh sind Konstanten, wobei in der Regel α = 1 gesetzt wird. σSh kann
durch die Anzahl der erwarteten Optima bestimmt werden. Da diese jedoch in
den meisten Fällen nicht bekannt sind, muss ein passender Wert gefunden werden.
Vorteil dieses Verfahrens ist, dass Chromosomen, die in einer kleineren Nische
auftreten, bevorzugt werden (vgl. [IG04] S. 72f, [HB89] S. 73ff).
4.3.5 Mehrkriterienoptimierung
Viele Probleme, die mit Hilfe genetischer Algorithmen gelöst werden sollen, weisen
mehrere Kriterien auf, die die Individuen erfüllen müssen. So könnte bei der Lösung des Traveling Salesman Problems nicht nur die zurückzulegende Wegstrecke,
sondern auch die Fahrzeit, die sich durch unterschiedliche Strassentypen ergibt, in
die Bewertung einfließen. Für k Kriterien errechnet sich die Fitness dann durch:
f it(c) =
k
X
αi f iti (c)
i=1
wobei αi eine Gewichtung des jeweiligen Kriteriums darstellt. Die Fitness zum jeweiligen Kriterium kann wiederum durch eines der bisherigen Verfahren berechnet
werden (vgl. [IG04] S. 73ff).
4.3.6 Fitnessfunktion mit Zusatzbedingungen
In vielen Fällen teilt sich der Lösungsraum eines Optimierungsproblems in erlaubte und verbotene Zonen auf, in denen sich die Individuen aufhalten. Um den Ort“
”
eines Individuums festzustellen, werden Rand- bzw. Nebenbedingungen erhoben,
die erfüllt sein müssen, damit das Chromosom eine korrekte Lösung liefert. Um
Chromosomen aus einer verbotenen Zone heraus zu manövrieren, wird ein Strafwert (penalty) pen(c) verwendet. Liegt dieser Wert bei 0, hat das Chromosom alle
Bedingungen erfüllt und befindet sich im erlaubten Bereich. Zusätzlich zu dem
Strafwert fließt eine populationsabhängige Gewichtungsfunktion w(t) in die Berechnung ein:
f it(c) = f it∗ (c) + w(t) ∗ pen(c)
Die Gewichtung w(t) könnte sich durch
w(t) = α ∗
t
T
errechnen, wobei α eine Konstante ist, t die aktuelle Generation und T die maximale Anzahl an Generationen. Dabei sollte darauf geachtet werden, dass die Gewichtung nicht zu groß ausfällt, da dadurch die eigentliche Fitness vernachlässigt
wird. Zusätzlich besteht die Gefahr, dass der Algorithmus auf schnell gefundene
korrekte, aber nur suboptimale Lösungen konvergiert (vgl. [IG04] S. 76ff).
4.4 Selektionsverfahren
33
4.4 Selektionsverfahren
Die Auswahl der Chromosomen bzw. der Individuen, aus denen die Nachfolgegeneration gebildet werden soll und auf die die genetischen Operatoren angewendet
werden, wird Selektion genannt. Im Laufe der Zeit sind viele verschiedene Verfahren entwickelt worden, die diese Auswahl treffen. Die Aufgabe eines Selektionsverfahren besteht in der Berechnung einer Selektionswahrscheinlichkeit pt (ci ) für
jedes Chromosom ci mit i ∈ {1, ..., popsize} zu einem Zeitpunkt t. Dabei werden
mehrere Ansätze verfolgt:
1. Bei statischen Selektionsfunktionen wird die Selektionswahrscheinlichkeit im
Vorfeld festgelegt, ist für alle Chromosomen gleich und ändert sich im Laufe
der Berechnungen nicht.
2. Dynamische Selektionsfunktionen berechnen die Selektionswahrscheinlichkeit
für jedes Individuum einer Generation neu.
3. Diskriminierende Selektionsverfahren bevorzugen die stärksten Individuen einer Population und bestimmen deren Selektionswahrscheinlichkeit auf Grund
ihrer Fitness. Dabei kann es sein, dass schwächere Chromosomen eine Selektionswahrscheinlichkeit von 0 erhalten.
4. Nicht diskriminierende Selektionsverfahren ermöglichen auch schwächeren Individuen, sich fortzupflanzen, wodurch eine mögliche vorzeitige Konvergenz verhindert werden kann.
5. Die Eliteselektion sieht die Übernahme der k (k > 0) besten Chromosomen in
die nächste Generation vor.
6. Die reine Selektion überlässt den kompletten Auswahlvorgang dem Zufall.
Um die einzelnen Verfahren untereinander zu vergleichen bzw. deren Unterschiede herauszufiltern, wurden zwei Messwerte entwickelt:
1. Der Bias, der die Abweichung der erwarteten Anzahl der Kopien eines Chromosoms von der tatsächlichen Anzahl der Kopien, die in die Auswahl aufgenommen werden, bestimmt.
2. Der Spread, der die Spannweite der Anzahl der unterschiedlichen gewählten
Chromosomen beschreibt (vgl. [IG04] S.79ff).
Die Auswahl der Chromosomen, die zur Erzeugung der nächsten Generation benötigt werden, erfolgt durch die Roulettrad-Selektion. Dieses Verfahren benötigt
eine vorher berechnete Selektionswahrscheinlichkeit p(c), die die Wahrscheinlichkeit eines Chromosoms c angibt, in diese Auswahl aufgenommen zu werden. Um
diese Selektionswahrscheinlichkeit zu bestimmen, gibt es mehrere Verfahren, von
denen einige im nächsten Abschnitt vorgestellt werden. Die neue Population P (t)
ergibt sich bei diesem Verfahren wie folgt:
• Berechnen einer Zufallszahl r ∈ [0, 1].
• ci ∈ P (t − 1) mit i ∈ {1, ..., popsize} wird in die neue Population P (t) aufgenommen, wenn gilt:
j<i
j≤i
X
X
p(cj ) ≤ r <
p(cj )
j=0
j=0
4.4 Selektionsverfahren
34
Dieses Vorgehen wird popsize-mal wiederholt. Abbildung 4.8 zeigt ein Beispiel
der Roulettrad-Selektion, bei der die Zufallszahl r die Funktion des Roulettrades
übernimmt (vgl. [IG04] S.39).
Abbildung 4.8. Überlebens-/Vermehrungswahrscheinlichkeit (Quelle: [IG04] S.
39)
Im Folgenden werden verschiedene Selektionsverfahren und deren Eigenschaften
vorgestellt.
4.4.1 Stochastic Sampling with Replacement
Dieses Verfahren ist das gängigste, um die Selektionswahrscheinlichkeit für die
Roulettrad-Selektion zu berechnen und findet sich in deshalb auch unter eben
diesem Namen in einiger Literatur wieder. Die Selektionswahrscheinlichkeit des
i-ten Chromosoms berechnet sich bei diesem Verfahren wie folgt:
f it(ci )
p(ci ) = P
f it(c)
c∈P (t)
Falls die Summe der einzelnen Fitnesswerte bei 0 liegt, erhält jedes Chromosom
1
.
die einheitliche Selektionswahrscheinlichkeit p(c) = popsize
Der Bias dieses Verfahrens ist sehr hoch. Es kann sogar passieren, dass das beste
Chromosom nicht in die nächste Generation aufgenommen wird. Dieser Umstand
unterstreicht, dass es sich hier um ein nicht diskriminierendes Verfahren dynamischer Natur handelt. Dynamisch deshalb, weil die Selektionswahrscheinlichkeiten
in jeder Generation neu berechnet werden müssen (vgl. [IG04] S.38f, 80).
4.4.2 Remainder Stochastic Sampling
Das Remainder Stochastic Sampling gibt es in zwei Varianten. Einmal mit Zurücklegen und einmal ohne. Die ersten Schritte sehen in beiden Varianten allerdings
gleich aus:
4.4 Selektionsverfahren
35
• Die Selektionswahrscheinlichkeit p(c) wird zunächst auf üblichem Wege erzeugt:
f it(ci )
p(ci ) = P
f it(c)
c∈P (t)
• Von jedem Chromosom c ∈ P (t − 1) werden dann zunächst bp(c) ∗ popsizec
Chromosomen direkt in P ∗ (t), einer Art Zwischenpopulation, eingefügt. In der
Regel ist die Population nach diesem Schritt noch nicht vollständig und die
Folgeschritte unterscheiden sich je nach Variante.
• Eine neue Fitness wird für jedes Chromosom c errechnet:
ff
it(c) := p(c) ∗ popsize − bp(c) ∗ popsizec
Im mit Zurücklegen-Fall werden die fehlenden Chromosomen anhand der Selektionswahrscheinlichkeit pe(c), die sich aus der neuen Fitness ff
it(c) ergibt, durch
die Roulettrad-Selektion ausgewählt.
Im anderen Fall, ohne Zurücklegen, wird die Finess ff
it(c) direkt als Auswahlwahrscheinlichkeit verwendet und bei jedem Chromosom der Reihe nach ausgewürfelt, ob es in die nächste Generation eintreten darf oder nicht.
Remainder Stochastic Sampling ist ein dynamisches, nicht diskriminierendes
Elite-Selektionsverfahren, bei dem die besten Individuen in jedem Fall überleben,
den schwächeren aber auch eine Überlebenschance gegeben wird. Zusätzlich werden
Bias und Spread im Vergleich zum Stochastic Sampling deutlich verringert (vgl.
[IG04] S.81f).
4.4.3 Stochastic Universal Sampling
Das Stochastic Universal Sampling arbeitet ähnlich wie das Stochastic Sampling,
schafft es aber, einen Bias von 0 und einen minimalen Spread zu erzeugen. Die Selektionswahrscheinlichkeit wird auf die gleiche Art und Weise berechnet. Abhängig
von dieser Wahrscheinlichkeit ist diesmal auch die Anzahl der ausgewählten Chromosomen. Diese berechnet sich p(t) ∗ popsize.
Auch hier handelt es sich um eine dynamische, nicht diskriminierende EliteSelektion (vgl. [IG04] S.82f).
4.4.4 Boltzmann Selektion
Die Besonderheit der Boltzmann Selektion liegt in der Einführung einer sogenannten Temperaturvariablen T , die zur Bestimmung der Selektionswahrscheinlichkeit
einbezogen wird:
ef it(ci )/T
P
p(ci ) =
ef it(c)/T
c∈P (t)
Im Laufe mehrerer Generationen sinkt die Temperatur T . Dadurch werden die
Unterschiede zwischen hoher und niedriger Fitness grösser, was zu einem höheren
Selektionsdruck führt. Daraus ergibt sich ein dynamisch, nicht diskriminierendes,
reines Selektionsverfahren, bei dem das Überleben des stärksten Individuums nicht
garantiert wird (vgl. [IG04] S.83).
4.4 Selektionsverfahren
36
4.4.5 Lineares Ranking
Hauptziel des linearen Rankings ist die Verhinderung der vorzeitigen Konvergenz
des genetischen Algorithmus. Dabei geht diesmal die Fitness der einzelnen Chromosomen nur bedingt auf deren Selektionswahrscheinlichkeit ein. Das Verfahren
geht von einer, nach der Fitness, absteigenden Sortierung der Chromosomen aus.
Es werden zwei Erwartungswerte festgelegt:
• Emax mit 1 ≤ Emax ≤ 2 für die Anzahl der Kopien des besten und
• Emin mit Emin = 2 − Emax für die Anzahl der Kopien des schlechtesten Chromosoms.
Die Festlegung von Emax und Emin muss folgende Bedingung erfüllen:
popsize
∀i ∈ {1, ..., popsize} : p(ci ) ≥ 0 und
X
p(ci ) = 1
i=1
Die Selektionswahrscheinlichkeit p(ci ) wird durch
i−1
1
∗ Emax − (Emax − Emin ) ∗
p(ci ) =
popsize
popsize − 1
errechnet.
Lineares Ranking ist ein reines, statisches Selektionsverfahren und nur dann
diskriminierend, falls Emax = 2. Aber auch hier müssen Spread und Bias relativ
hoch eingeschätzt werden (vgl. [IG04] S.83f).
4.4.6 Wettkampf-Selektion
Bei diesem Verfahren werden popsize Wettkämpfe zur Übernahme in die nächste
Generation geführt. Ein solcher Wettkampf wird von q vielen Chromosomen bestritten, die zufällig ausgewählt werden. Das Chromosom mit der höchsten Fitness
überlebt. Werden die Chromosomen absteigend bezüglich ihrer Fitness sortiert, ist
es möglich, die Selektionswahrscheinlich, so Bäck, mathematisch zu bestimmen:
pi =
1
∗ ((popsize − i + 1)q − (popsize − i)q )
q
popsize
.
Der Selektionsdruck kann bei diesem Verfahren durch die Anzahl der Wettkämpfer q reguliert werden. Bias und Spread liegen hier relativ hoch. Die WettkampfSelektion ist ein reines, statisches und nicht diskriminierendes Auswahlverfahren
(vgl. [IG04] S.84f).
4.4.7 Steady State Reproduktion
Dieses Verfahren unterscheidet sich wesentlich von allen bisher vorgestellten. Hier
werden nur soviele Chromosomen zufällig ausgewählt, auf denen ein genetischer
4.5 Rekombination
37
Operator, sei es Mutation oder Cross-over, angewendet werden soll. Für die Auswahl der zu verändernden Chromosomen können allerdings bekannte Selektionsverfahren verwendet werden. Das Einsetzen der neuen Individuen ist über mehrere
Verfahren möglich:
• Ersetzen der schlechtesten Chromosomen.
• Ersetzen zufällig ausgewählter Chromosomen oder
• Ersetzen mit Hilfe eines exponentiellen Rankings.
Der Name rührt daher, dass nicht die ganze Population ausgetauscht wird, sondern
nur ein Teil (vgl. [IG04] S.85).
4.4.8 Deterministisches Crowding
Ein Ansatz zur Verhinderung von Konvergenz sind Nischentechniken. Deterministisches Crowding ist ein Vertreter dieser Methode. Nach Anwenden der genetischen
Operatoren werden die neuen Individuen mit der Elterngeneration verglichen und
ersetzen das Chromosom, dem sie am ähnlichsten sind. Dieser Vergleich kann sowohl auf die genetische Struktur als auch phänotypisch erfolgen. Hier ist folglich
das grösste Problem dieses Verfahrens angesiedelt: Es muss jeweils ein Vergleichsbzw. Ähnlichkeitsmaß definiert werden. Aber auf diesem Weg wird verhindert, dass
sich einige wenige Lösungen durchsetzen (vgl. [IG04] S.86).
4.5 Rekombination
Rekombination oder Crossover ist neben der Mutation einer der beiden genetischen Operatoren eines genetischen Algorithmus und greift damit ein wichtiges
Konzept der Natur auf: die Verteilung des Erbmaterials zweier Individuen auf ihre
Nachkommen.
Im Wesentlichen werden drei verschiedene Arten von Crossover unterschieden:
• allgemeines Crossover,
• Crossover-Operatoren für Reihenfolgeprobleme (z.B. TSP) und
• Inversion.
4.5.1 One-point-crossover
Der einfachste Crossover-Operator, das one-point-crossover, wurde bereits auf Seite
28 beschrieben. Hierbei werden zwei Chromosomen an jeweils der gleichen Stelle
geteilt und deren Enden miteinander vertauscht.
Das grösste Problem dieses Verfahrens ist der Positional Bias“, der die Abhän”
gigkeit der Austauschwahrscheinlichkeit eines Gens von dessen Position im Chromosom beschreibt. Die Wahrscheinlichkeit, das erste Allel auszutauschen liegt bei
0, die Wahrscheinlichkeit des letzten Allels bei 1. Auch die Anzahl neuer Chromosomen hält sich durch die Verteilung von nur zwei Teilstücken in Grenzen (vgl.
[IG04] S.40, 87).
4.5 Rekombination
38
4.5.2 Two-point-Crossover
Das two-point-crossover ist eine Erweiterung des einfachen Crossover-Operators.
Hierbei werden zwei Punkte auf den Elternchromosomen gewählt, zwischen denen
der Austausch stattfindet, was auch in Abbildung 4.9 zu sehen ist.
cross-over
Abbildung 4.9. Two-Point-Crossover (Quelle: [IG04] S.88)
Nun könnte die Vermutung entstehen, dass auch, oder gerade, in diesem Verfahren der positional bias greift. Dies wird dadurch verhindert, dass das Chromosom
als Ring interpretiert wird (siehe Abbildung 4.10). Durch diese Art der Interpretation ist es möglich, dass ein Bereich gewählt wird, der sowohl das erste als auch
das letzte Allel einschließt (vgl. [IG04] S.88).
Abbildung 4.10. Two-Point-Crossover mit Ringinterpretation des Chromosoms
(i.A.a. [IG04] S.88)
4.5.3 k-point-Crossover
Statt sich auf ein oder zwei Kreuzungspunkte festzulegen, ist es auch möglich,
deren Anzahl auf k zu erhöhen. Je höher k gewählt wird, desto niedriger ist der
positional bias. Auch bei diesem Verfahren wird ein Chromosom als Ring aufgefasst. Abbildung 4.11 zeigt ein 4-point-Crossover (vgl. [IG04] S.89).
4.5.4 Parametrisiertes Uniform Crossover
Das parametrisierte Crossover arbeitet ähnlich wie das k-point-Crossover. Allerdings wird hierbei für jedes Allel gewürfelt, ob es ausgetauscht werden soll oder
4.5 Rekombination
39
cross-over
Abbildung 4.11. 4-Point-Crossover (i.A.a. [IG04] S.89)
nicht. Die Austauschwahrscheinlichkeit pc wird dabei im Vorfeld festgelegt und
liegt in der Regel zwischen 0.5 und 0.8. Ist pc = 0.5, spricht man auch vom Uni”
form Crossover“ (vgl. [IG04] S.89).
cross-over
Abbildung 4.12. Beispiel parametrisiertes Uniform Crossover (i.A.a. [IG04] S.89)
4.5.5 Shuffle Crossover
Ein weiterer Versuch den positional bias zu unterbinden, ist das Shuffle Crossover,
bei dem drei wesentliche Schritt gemacht werden:
1. Bei beiden beteiligten Chromosomen wird die Reihenfolge der Allele zufällig
durcheinander gewürfelt. Die neue Reihenfolge ist bei beiden Chromosomen
gleich.
2. Anwendung eines Crossover-Operators. Dabei kann jedes der bereits bekannten
Verfahren eingesetzt werden.
3. Wiederherstellen der alten Reihenfolge auf beiden Chromosomen.
Durch dieses Verfahren kann der positional bias selbst beim one-point-Crossover
auf Null reduziert werden (vgl. [IG04] S.90).
4.5.6 Punctuated Crossover
Das Punctuated Crossover ist eine Erweiterung des k-point-Crossover, wobei versucht wird, die Punkte, an denen das Crossover durchgeführt wird, neben den
eigentlichen Chromosomen weiter zu entwickeln. Um dies zu erreichen, wird jedes
4.6 Mutation
40
Chromosom um einen Bitstring der Länge l erweitert. Eine 1 auf diesem erweiterten Teilstück besagt, dass das Chromosom an der entsprechenden Stelle geteilt
werden darf, eine 0 verbietet eine Teilung an der entsprechenden Stelle. Diese Chromosomenerweiterung wird im Verlauf des Algorithmus nur bei der Rekombination verwendet, Mutation und Berechnung der Fitness beachten diese Erweiterung
nicht.
Vom Einsatz dieser Strategie wird erhofft, dass sich Kreuzungspunkte mit besonders positivem Einfluss herauskristallisieren und jene, die einen zerstörerischen
Einfluss auf gute Chromosomen nehmen könnten, unterbunden werden (vgl. [IG04]
S.90).
4.5.7 Inversion
Die Inversion ist im Grunde auch eine Erweiterung des two-point-Crossovers, mit
deren Hilfe eine Umordnung von besonders erfolgreichen Gensequenzen und damit
deren Verbesserung stattfinden soll.
Der Name verrät das Vorgehen dieses Verfahrens: Die Reihenfolge der Gene
zwischen den beiden Kreuzungspunkten wird vor der Rekombination umgedreht,
was in Abbildung 4.13 gezeigt wird.
1 2 3 4 5 6 7 8 9
1 2 6 5 4 3 7 8 9
Abbildung 4.13. Inversion (Quelle: [IG04] S.98)
Wird das Chromosom nicht als Ring aufgefasst, erhöht sich auch hier der positional bias (vgl. [IG04] S.97f).
4.6 Mutation
Die Mutation spielt, wie auch in der Natur, beim genetischen Algorithmus keine
grosse Rolle. Sie dient im Wesentlichen dazu, ein lokales Optimum zu überspringen
und die Evolution damit etwas anzutreiben. Die von einer Mutation betroffenen
Chromosomen müssen üblicherweise auch nicht die beste Fitness vorweisen, wie es
beim Crossover oft der Fall ist. Dort wird versucht, das Beste aus zwei Chromosomen zu kombinieren. Die Mutation verändert einfach nur die vorliegenden Gene,
wobei das Ergebnis dieses Operators nicht unbedingt zu einer Verbesserung führen
muss.
Aus diesem Grund gibt es auch nur vergleichsweise wenige Verfahren, die sich
mit der Mutation beschäftigen. Liegen die Chromosomen in Form eines Bitstrings
vor, wird üblicherweise eine Mutationswahrscheinlichkeit von 1/n gewählt, wobei
4.7 Genetische Programmierung
41
n die Anzahl der Gene im Chromosom ist. Fällt nun ein Gen einer Mutation zum
Opfer, wird das Bit einfach gekippt, d.h. aus einer 0 wird eine 1 und aus einer 1
wird eine 0 (vgl. [IG04] S.40ff, 98f).
4.6.1 Non Uniform Mutation
Ein Verfahren, das eingesetzt wird, falls die Gene von reellen Zahlen repräsentiert
werden, ist die Non Uniform Mutation. In diesem Verfahren nimmt das Alter der
Population Einfluss auf die Mutation.
Sei c = (a1 , ..., al ) ein Chromosom mit ai ∈ R und ak das für die Mutation
gewählte Gen. ∆(x, y) ist eine mit steigendem x monoton fallende Funktion, die
später durch die Generation beinflusst wird, und mit ak ∗ ∆(x, y) den Definitionsbereich [uk , ..., ok ] besitzt. Mit Hilfe einer binären Zufallszahl z errechnet sich die
Änderung des Gens ak wie folgt:
(
ak + ∆(t, ok − ak ) falls z = 0
a0k =
ak − ∆(t, ak − uk ) falls z = 1
Da ∆(x, y) mit steigender Generationenzahl sinkt, werden die Veränderungen
im Laufe der Zeit immer geringer, wodurch verhindert werden soll, dass gut ausgebildete Individuen zerstört werden können (vgl. [IG04] S.99f).
4.7 Genetische Programmierung
Die Genetische Programmierung wurde Anfang der 1990er von Koza entwickelt
und stellt eine Abwandlung des einfachen genetischen Algorithmus dar. Interessant
dabei ist, dass die verwendeten Chromosomen keine feste Länge mehr benötigen,
sondern dass diese variieren kann. Statt einen Zeichenstring zu verwenden, besteht
ein Chromosom bei der genetischen Programmierung aus einer Liste bzw. einem
Programmbaum. Besonders geeignet dafür ist die Programmiersprache LISP (LISt
Processing), aus deren Listen eine Baumstruktur hergestellt werden kann.
Ein Chromosom C setzt sich aus Funktionssymbolen F und Terminalsymbolen
T zusammen. Im einfachsten Fall könnten auch hier die Terminalsymbole 0 und 1
(T = {0, 1}) und entsprechende binäre Funktionen
F = {and, or, not, if..then..else}
verwendet werden. Möglich wären aber auch Variablen und Konstanten, die reelle
Werte annehmen können und entsprechende Funktionen, wie Division, Multiplikation, Logarithmus, usw. Zwei Beispielprogramme und deren entsprechende Bäume
werden in Abbildung 4.14 gezeigt.
Auch hier sind die genetischen Operatoren Rekombination (crossover) und Mutation möglich, wobei in den meisten Fällen der genetischen Programmierung auf
die Mutation verzichtet wird, da der crossover-Operator hier reichhaltiger“ als bei
”
den genetischen Algorithmen ist. Eine Rekombination zweier Chromosomen wird
einfach durch den Austausch zweier Knoten und deren Unterbäumen realisiert
(siehe Abbildung 4.15) (vgl. [IG04] S. 127ff).
4.7 Genetische Programmierung
42
+
+
3
*
2
5
3
IF
>
6
5
x
6
y
Abbildung 4.14. Beispielprogramme als Bäume (Quelle: [IG04] S. 129)
or
or
or
x1
and
and
not
not
not
not
x0
x0
x1
x0
x0
x1
crossover
or
or
x1
or
not
not
x0
x0
and
and
not
not
x0
x1
x0
x1
Abbildung 4.15. Crossover: Austausch ausgewählter Teilbäume (Quelle: [IG04]
S. 131f)
5
Künstliche Neuronale Netze
Mit künstlichen neuronalen Netzen (kurz: kNN) wird versucht, Eigenschaften natürlicher Gehirne in der Technik nachzubilden. Dazu zählen die Fähigkeiten zu Lernen, zu abstrahieren oder zu klassifizieren. All diese Eigenschaften können durch
künstliche neuronale Netze erreicht werden.
Dabei ist wichtig herauszuheben, dass künstliche neuronale Netze eine völlig
neue Technologie der Informationsverarbeitung darstellen. Die sonst gebräuchliche von Neumann-Architektur wird hier nicht verwendet, da künstliche neuronale
Netze hochgradig parallel arbeiten müssen. Allerdings werden kNNs selten in die
Praxis umgesetzt, sondern in der Regel auf herkömmlichen Rechnern - eben mit
von Neumanns Architektur - simuliert.
5.1 Neuronale Netze in der Natur
Vorbild künstlicher neuronaler Netze sind Gehirne bzw. Nervensysteme von Wirbeltieren. Diese bestehen aus vielen Milliarden (ca. 100 Milliarden beim Menschen)
Neuronen, die massiv parallel arbeiten und untereinander durch ein engmaschiges
Netz verbunden sind.
Neuronen sind Nervenzellen, eben der Zelltyp, der in Gehirnen auftritt. Die Besonderheit im Gegensatz zu anderen Zellen ist, dass sich Neuronen nicht erneuern
können. Andere Zellen, z.B. die der Haut, sterben ab und werden durch neue ersetzt, wozu die Nervenzellen nicht in der Lage sind. Die Verbindungen zwischen
den Neuronen werden in den ersten Lebensjahren ausgebildet. Die Leistungsfähigkeit erhält ein solches Nervensystem vor allem durch dessen extreme Vernetzung,
wodurch ein einzelnes Neuron keine direkten Aufgaben hat und entsprechend entbehrlich ist. Das zeigt, dass ein solches Nervensystem vor allem durch seine Architektur der enormen Vernetzung profitiert (vgl. [JS91] S. 19ff, 36ff, [Zel94] S. 23f,
35ff).
5.2 Aufbau und Funktionsweise einer Nervenzelle
Abbildung 5.1 zeigt die wichtigsten Elemente einer Nervenzelle.
5.2 Aufbau und Funktionsweise einer Nervenzelle
44
Abbildung 5.1. Ein typisches Neuron (Nervenzelle) (Quelle:[JS91] S. 36)
Der Zellkörper (Soma) unterscheidet sich nicht wesentlich von üblichen Zellen.
Der Unterschied liegt hier vor allem in der Funktionalität und dass er sich, im
Gegensatz zu herkömmlichen Zellen, nicht teilen kann. Im Soma werden die eingegangen Signale aufgefangen und aufsummiert. Ob und wie stark ein Neuron auf
ein ankommendes Signal reagiert, wird ebenfalls im Soma entschieden.
Die Signale empfängt das Neuron über die Dendriten, hauchdünne Geißel, die
ankommende Signale anderer Zellen aufnehmen und an den Zellkörper weiterleiten.
Das Ausgangssignal einer Nervenzelle wird über eine Nervenfaser, das Axon,
weitergeleitet, dessen Länge zwischen einigen Millimetern bis zu fast einem Meter
liegen kann. Über diese Strecke muss ein Axon in der Lage sein, ein Signal an
andere Neuronen weiterzuleiten. Die Signalübertragung erfolgt über Ionenströme.
Im Inneren des Axons häufen sich positiv geladene Kaliumionen. Ausserhalb eines
Axons herrscht eine niedrigere Konzentration positiver Ladung vor. Durch eine
Wanderung der Kaliumionen aus dem Axon heraus soll dieses Konzentrationsgefälle ausgeglichen werden. Nach diesem Spannungsausgleich liegt die Spannungsdifferenz bei 40 bis 60 Millivolt. Dieser Zustand wird Ruhepotential bezeichnet.
Das Soma nimmt nun solange elektrische Signale auf, bis es die Schwelle von ca.
70 Millivolt überschreitet. Nachdem diese Schwelle übertreten wurde, schnellt das
elektrische Potenzial in die Höhe und das Neuron feuert“ mit ungefähr 100 Milli”
volt. Dieser Impuls, der nun über das Axon zu anderen Neuronen übertragen wird,
nennt sich Aktionspotential. Zwischen zwei Aktionspotentialen benötigt eine Nervenzelle eine gewisse Erholungsphase, in der es in den Bereich des Ruhepotentials
zurückfällt. Dadurch wird eine dauerhafte Erregung verhindert.
Die Endknöpfchen, an denen ein Axon auf die Dendriten einer anderen Nervenzelle trifft, werden Synapsen genannt. Diese wirken entweder erregend oder
hemmend auf die empfangende Nervenzelle (vgl. [JS91] S. 36ff, [Zel94] S. 35ff,
[HB89] S. 204ff, [Caw03] S. 191f).
5.3 Neuronale Netze in der Informatik
45
5.3 Neuronale Netze in der Informatik
5.3.1 Netzaufbau
Künstliche neuronale Netze orientieren sich in ihren Aufbau zwar an dem biologischen Vorbild der Nervenzelle, idealisieren diese jedoch stark. Genauso wie ihr
Vorbild bestehen Neuronen eines kNN aus drei wesentlichen Bestandteilen:
1. dem Zellkörper, in dem die Summenbildung der Eingangssignale erfolgt und
der den Ausgangsimpuls erzeugt,
2. die Dendriten, über die die Eingangssignale eintreffen und
3. dem Axon, das den Impuls einer Zelle an das Netz weitergibt.
Die Synapsen werden durch Verbindungsgewichte realisiert, die das Eingangssignal
hemmen oder verstärken können.
Die Ausgabe einer Zelle, also eines Neurons, wird aus drei Bestandteilen ermittelt:
1. Der Aktivierungszustand ai (t), der die Aktivierung einer Zelle i zum Zeitpunkt
t beschreibt.
2. Die Aktivierungsfunktion fact , die den Aktivierungszustand aj (t + 1) des Neurons j zum Zeitpunkt t + 1 berechnet. Diese Berechnung erfolgt unter Einfluss
der vorangegangenen Aktivierung aj (t), der Netzeingabe netj (t) und einem
Schwellwert Θj :
aj (t + 1) = fact (aj (t), netj (t), Θj ).
3. Eine Ausgabefunktion fout , die das Ausgabesignal der Zelle anhand der Aktivierung errechnet:
oj = fout (aj ).
Als Ausgabefunktion wird sehr häufig die Identität (id) verwendet. Dadurch wird
die Ausgabe hauptsächlich durch die Aktivierungsfunktion bestimmt, für die häufig
sigmoide (S-förmige) Funktionen, wie sin, tanh oder die logistische Funktion 1+e1−x
verwendet werden.
Das Netz selbst kann als gerichteter, gewichteter Graph verstanden werden. Dabei stellen die Kanten die gewichteten Verbindungen zwischen den Neuronen dar.
Das Gewicht (weight) zwischen Zelle i und Zelle j wird demnach wij bezeichnet. In
Abbildung 5.2 werden unterschiedliche Verbindungsmöglichkeiten und die daraus
resultierenden Topologien gezeigt. Besteht zwischen zwei Zellen keine Verbindung,
wird dies durch eine 0 in der Gewichtsmatrix gekennzeichnet.
Die für die Aktivierung benötigte Netzeingabe netj (t) berechnet sich wie folgt
aus den jeweiligen Aktivierungen bzw. Ausgaben der mit einer Zelle verbunden
Neuronen und den jeweiligen Gewichtungen dieser Verbindungen:
X
netj (t) =
oi (t)wij
i
womit auch die Aufsummierung der eintreffenden Signale, wie sie im biologischen
Vorbild erfolgt, mathematisch umgesetzt ist (vgl. [Zel94] S. 71ff).
5.4 Lernverfahren
46
a) feedforward, ebenweise verbunden
b) feedforward mit shortcut connections
c) direkte Rückkopplung
d) indirekte Rückkopplung
e) laterale Rückkopplung
f) vollständig verbunden ohne direkte Rückkopplung
Abbildung
5.2.
(Quelle:[Zel94] S. 79)
Beispiel-Topologien
und
ihre
Verbindungsmatrizen
5.4 Lernverfahren
Neuronale Netze sind wie ihre natürlichen Vorbilder lernfähig. Im Falle künstlicher
neuronaler Netze zielt das Lernen auf eine Veränderung der Netzgewichte ab. Dabei
werden drei verschiedene Ansätze unterschieden:
Überwachtes Lernen (supervised learning): Die Überwachung bei dieser Methode übernimmt ein externer Lehrer“. Das Netz wird auf verschiedene Ein”
gabemuster trainiert, indem es zu den jeweiligen Eingabewerten das korrekte
bzw. das erwartete Ausgabemuster zum Vergleich zu seiner eigenen Ausgabe
erhält. Mit Hilfe dieser Vergleichsdaten werden die Netzgewichte angepasst. Ziel
dieses Trainings ist es, möglichst viele Übereinstimmungen zwischen Netzausgabe und übergebenem Ausgabemuster zu erhalten. Das überwachte Lernen ist
die schnellste Möglichkeit, ein Netz zu trainieren. Allerdings ist dieser Ansatz
biologisch nicht sehr plausibel, da die Aktivierungen der Ausgabeneuronen vorgegeben werden. Ein weiteres Problem ergibt sich, wenn keine ausreichenden
Daten vorliegen, die das Netz einstudieren könnte.
Bestärkendes Lernen (reinforcement learning) ist eher aus von der Natur
abgeleitet. Ein Lehrer“ sagt dem Netz, ob seine Ausgabe zu dem gegebenen
”
5.5 Backpropagation
47
Eingabemuster richtig oder falsch ist (Belohnung oder Bestrafung). Alternativ kann dem Netz auch ein Korrektheitsgrad zur Kontrolle gegeben werden,
im Sinne einer prozentualen Korrektheit. Ein solcher Korrektheitsgrad ist vergleichbar mit der Fitnessfunktion eines genetischen Algorithmus. In der Praxis
findet diese Methode eher weniger Anklang, da sie viel mehr Zeit in Anspruch
nimmt als die des überwachten Lernens.
Unüberwachtes Lernen (unsupervised learning): Die von Kohonen entwickelten
Selbstorganisierenden Karten (self organizing maps: SOM) sind vergleichbar
mit dem visuellen Kortex von Säugetieren und dienen letztendlich zur Klassifizierung der Eingabedaten. Das Verfahren wird deshalb unüberwacht bezeichnet, da das Netz über die Gewichtsänderungen entscheidet und hierfür kein
Ausgabemuster benötigt.
Neuronale Netze stellen für den Benutzer eine Black-Box dar. In den seltensten
Fällen ist es möglich, den Grund für die Gewichtung einer Verbindung nachzuvollziehen (vgl. [Zel94] S. 93ff, [Caw03] S. 195ff).
5.5 Backpropagation
Backpropagation ist die populärste Methode zum überwachten Lernen vorwärtsgerichteter Netze. Das Verfahren wurde zudem vielfach modifiziert, um es für
verschiedene Problemstellungen zu optimieren oder um es zusätzlich für rückgekoppelte Netze verwenden zu können. Dieser Abschnitt stellt den einfachen
Backpropagation-Algorithmus vor.
Backpropagation ist ein Gradientenabstiegsverfahren, das den Fehler, den das
Netz verursacht, minimieren soll. Der Fehler eines Netzes entsteht durch die Belegung seiner Gewichte:
E(W ) = E(w1 , ..., wn )
d.h. der Algorithmus soll möglichst schnell eine Gewichtsverteilung berechnen, die
ein globales Minimum der Fehlerfunktion darstellt.
Das Verfahren benötigt eine Reihe von Eingabemustern und passenden Ausgabemustern, die es zu trainieren gilt. Das Netz sollte mehrmals mit denselben
Mustern trainiert werden. Die Gewichtsänderung für das Backpropagation wird
von der Delta-Lernregel (Widrow-Hoff-Regel) abgeleitet und berechnet sich wie
folgt:
X
∆wij = η
opi δpj
p
Wobei p das jeweilige Eingabemuster (pattern) darstellt, η den Lernfaktor oder die
Schrittweite bezeichnet und üblicherweise zwischen 0 und 1 liegt, opi die Ausgabe
des Neurons j bei Eingabe p beschreibt und δ den Faktor bezeichnet, der sich je
nach Lage des Neurons entsprechend verändert:

0
fact
(netpj )(tpj − opj ) falls j Ausgabezelle
δpj = f 0 (net ) P δ w
falls j verdeckte Zelle
pj
pk jk
 act
k
5.6 Netzarchitekturen
48
allerdings kann dieser Ausdruck noch weiter vereinfacht werden, falls die logistische
Aktivierungsfunktion verwendet wird:

opj (1 − opj )(tpj − opj ) falls j Ausgabezelle
δpj = o (1 − o ) P δ w
falls j verdeckte Zelle
pj
pk jk
 pj
k
Der Wert tpj ist der Ausgabewert an der Stelle j, den es zu trainieren gilt.
Zusätzlich finden sich viele Ansätze, das Backpropagation auf weitere Architekturen, z.B. rückgekoppelte Netze, anzuwenden oder um typische Probleme, die
bei Gradientenverfahren auftreten, zu umgehen oder einzudämmen. Diese Verfahren werden an dieser Stelle jedoch nicht beschrieben, sondern finden sich in der
entsprechenden Literatur (vgl. [Zel94] S. 105ff, [Caw03] S. 195ff).
5.6 Netzarchitekturen
Im Laufe der Entwicklung künstlicher neuronaler Netze sind viele unterschiedliche
Ausprägungen entstanden, die entweder gezielt für bestimmte Problemstellungen
gedacht sind, oder die die Umsetzung unterschiedliche Konzepte der Natur verfolgen.
Die hier aufgeführte Liste erhebt keinen Anspruch auf Vollständigkeit. Vielmehr werden die Netztypen vorgestellt, die in dieser Arbeit zumindest kurzzeitig
Verwendung gefunden haben.
5.6.1 (Multi Layer) Perzeptron
Die Geschichte der künstlichen neuronalen Netze beginnt Anfang der 1960er mit
der Entwicklung des Perzeptrons von Frank Rosenblatt. Das Schema des Perzeptrons wird in Abbildung 5.3 dargestellt. Es besteht aus einer Eingabeschicht, die
über fest gewichtete Verbindungen mit der eigentlichen Verarbeitungsschicht verbunden ist. Diese besitzt Verbindungen mit trainierbaren Gewichten zu den Ausgabezellen.
Ebene 1
variable Verbindungen
Ebene 0
∑
festen
Verbindungen
Eingabeschicht
w1
o1
...
o2
wn
on
Abbildung 5.3. Schema des Perzeptrons (links) und Ausgabeneuron des Perzeptrons (rechts) (Quelle:[Zel94] S. 98)
5.6 Netzarchitekturen
49
Als Ausgabe- bzw. Aktivierungsfunktion wurde zu Beginn eine binäre Schwellwertfunktion verwendet, um binäre Funktionen zu berechnen. Die anfängliche Euphorie, die mit der Entdeckung des Perzeptrons einherging, fand ihr jähes Ende,
als man feststellte, dass diese Architektur noch nicht einmal in der Lage war, eine
einfache XOR-Berechnung durchzuführen.
Dieses Problem wurde allerdings Jahre später durch die Erweiterung des Netzes um eine weitere Schicht, der sogenannten verdeckten Schicht, behoben. Diese
Schicht kann wiederum aus mehreren Schichten bestehen, wobei alle Verbindungen, die daraus entstehen, trainierbar sind (siehe Abbildung 5.4). Diese Erweiterung nennt sich Multi Layer Perceptron (MLP) und beschreibt die gängigste
Netztopologie.
Eingabe
Ebene 1
Ebene 2
Ebene 3
Abbildung 5.4. Dreistufiges Perzeptron (i.A.a.:[Zel94] S. 102)
MLPs werden vorwiegend durch das überwachte Lernverfahren Backpropagation trainiert (vgl. [Zel94] S. 73f, 95ff, [Caw03] S. 192ff).
5.6.2 Elman-Netze
Elman-Netze bzw. die damit eng verwandten Jordan-Netze werden vermehrt zur
Zeitreihenanalyse verwendet. Darunter versteht man die Untersuchung zeitlich aufeinanderfolgender Muster, die nicht getrennt voneinander untersucht werden können, da eine gewisse Abhängigkeit zwischen den einzelnen Mustern besteht. Ein
typisches Einsatzgebiet von Zeitreihenanalysen sind Wetter- oder, noch spezieller,
Hochwasservorhersagen.
Um nun ein neuronales Netz empfänglich für solche Zeitreihen zu machen, erhält
es eine Art Kurzzeitgedächtnis, in welchem es sich seine letzten Zustände merken
kann. Dies wird technisch durch eine zusätzliche Neuronenschicht und einer 1:1
Rückkopplung der verdeckten Schicht erreicht, wie es in Abbildung 5.5 gezeigt
wird.
5.6 Netzarchitekturen
50
Eingabe
Kontext
trainierbare Gewichte
1:1 Übertragung
verdeckt
trainierbare Gewichte
Ausgabe
Abbildung 5.5. Architektur eines Elman-Netzes (i.A.a.:[Zel94], S. 141)
Jordan-Netze arbeiten ähnlich, jedoch werden die Kontextzellen dort mit der
Ausgabeschicht verbunden. Aber es ist auch möglich, die Topologie eines ElmanNetzes derart auszuweiten, dass, falls mehrere verdeckte Schichten existieren, sowohl diese als auch die Ausgabezellen über eine separate Kontextschicht verfügen.
Diese Erweiterung wird hierarchisches Elman-Netz genannt.
Häufig werden auch direkte Rückkopplungen der Kontextzellen verwendet, die
ebenfalls nicht trainierbar sind, sondern mit einem festen Gewicht λ belegt sind.
Zum Trainieren dieser sogenannten partiell rekurrenten Netze werden abgewandelte Formen des Backpropagation-Algorithmus verwendet (vgl. [Zel94] S. 137ff).
5.6.3 Selbstorganisierende Karten
Die selbstorganisierenden Karten (englisch: self organizing maps, SOM) oder, nach
Ihrem Entdecker“, Kohonen-Karten genannten Netze sind das Paradebeispiel für
”
Netze, die mittels unüberwachtem Lernen trainiert werden. Das hierbei entstehende Verhalten des Netzes ist sehr gut vergleichbar mit der Funktionalität der
Netzhaut eines Auges und wird vornehmlich zur Klassifikation oder Clusterbildung
verwendet.
Kohonen-Karten besitzen im Grunde nur eine Neuronenschicht zur Verarbeitung der Daten mit einer vorgeschalteten Eingabeschicht. Jedes Neuron der eigentlichen Verarbeitungsschicht ist über die üblichen gewichteten Verbindungen
mit der Eingabeschicht verbunden. Zusätzlich bestehen Verbindungen zwischen
den Neuronen der Verarbeitungsschicht, wodurch eine Nachbarschaftsbeziehung
entsteht, die später eine wichtige Rolle spielt. Abbildung 5.6 soll noch einmal verdeutlichen, dass jedes Neuron den n-dimensionalen Eingabevektor über n gewich-
5.6 Netzarchitekturen
51
tete Verbindungen erhält, und dass sie untereinander zu einem zweidimensionalen
Gitter verknüpft sind.
w1j
w2j
... wnj
Wj = (w1j, w2j,..., wnj)
Eingabeschicht
X = (x1j, x2,..., xn)
Abbildung 5.6. Netzstruktur der selbstorganisierenden Karten (i.A.a.:[Zel94] S.
180)
Das Lernen der Kohonen-Karten erfolgt unüberwacht, was bedeutet, dass keine
Musterlösungen zu den gegebenen Eingabemustern vorgegeben werden. Vielmehr
soll das Netz die zum Training verwendeten Daten in Cluster einteilen. Hierzu
wird zu jedem Eingabevektor X = (x1 , x2 , ..., xn ) das Neuron j gewählt, dessen
Gewichtsvektor Wj = (w1j , w2j , ..., wnj ) dem Eingabevektor am ähnlichsten ist:
kX − Wc k = minj (kX − Wj k)
wobei hier häufig die euklidische Norm oder das Skalarprodukt verwendet wird.
Das Neuron c beschreibt das Gewinnerneuron.
Die nun folgenden Änderungen der Gewichtsvektoren erfolgen nicht nur auf dem
Gewinnerneuron, sondern auch auf Neuronen, die sich in seiner Nähe“ befinden.
”
Mit der Distanz ist wirklich eine Entfernung gemeint und nicht etwa der Unterschied, der bei dem Vergleich der Eingabe mit den Gewichtsvektoren entsteht. Die
räumliche Distanz zwischen den Neuronen wird bei der Veranschaulichung einer
eindimensionalen Anordnung der Verarbeitungsschicht, wie sie in Abbildung 5.7
gezeigt wird, deutlich.
Nachbarschaftsradius
1
2
unverändert
3
verändert
4
5
6
stark verändert
7
8
9
verändert unverändert
Abbildung 5.7. Netzstruktur der selbstorganisierenden Karten (i.A.a.:[Zel94] S.
182)
5.7 Optimierung neuronaler Netze
52
Damit ist die Distanz zwischen den Neuronen, die mit der Funktion hcj (t) ermittelt wird, ein wichtiger Bestandteil der Berechnung der Gewichtsänderung des
Netzes:
Wj (t + 1) = Wj (t) + η(t)hcj (t) [X(t) − Wj (t)]
η(t) beschreibt die zeitlich veränderliche Lernrate, die überlicherweise durch eine
monoton fallende Funktion mit 0 < η(t) < 1 realisiert wird.
In der Praxis wird häufig auf den Zeitparameter t zur Berechnung der Distanz
verzichtet. Statt dessen wird ein Parameter d eingesetzt, der die Grösse des Nachbarschaftsradius angibt, und der Wert z = krc − rj k, der die Entfernung zwischen
den Neuronen bestimmt. Mit Hilfe dieser Parameter gibt es etliche Alternativen
zur Berechnung der Distanz:
2
hgauss (z, d) = e−(z/d)
(
1 falls z < d
hcylinder (z, d) =
0 sonst
(
1 − dz falls z < d
hcone (z, d) =
0
sonst
(
cos dz π2
falls z < d
hcos (z, d) =
0
sonst
Wie sich diese Nachbarschaftsfunktionen in einem zweidimensionalen Verbindungsgitter auswirken, zeigt Abbildung 5.8.
Abbildung 5.8. Distanzfunktionen hgauss , hcylinder , hcone und hcos (Quelle:[Zel94]
S. 183)
Abbildung 5.9 zeigt die Entfaltung einer solchen Kohonenkarte über den Zeitraum von 3000 Lernschritten. Die Gitternetzform entsteht durch die Verbindungen
zwischen den Neuronen. In diesem Fall verteilen sich die Eingabemuster nahezu
quadratisch auf die vorhandenen Neuronen (vgl. [Zel94] S. 179ff).
5.7 Optimierung neuronaler Netze
Mit künstlichen neuronalen Netzen ist es möglich, Fuzzy-Regel-Systeme, eine weitere Methode des Softcomputing, zu optimieren (vgl. [DN94]). Aber auch neuronale
5.7 Optimierung neuronaler Netze
53
Abbildung 5.9. Entfaltung einer Kohonenkarte (Quelle:[Zel94] S. 184)
Netze können optimiert werden. Dies ist durch eine geeignete Kombination neuronaler Netze und genetischer Algorithmen (siehe Kapitel 4) möglich, die auch als
Neuroevolution bezeichnet wird.
Ziel der Optimierung neuronaler Netze ist die Minimierung der Fehlerfunktion
E(W ), die durch die Werte der Verbindungsgewichte errechnet wird. Das bedeutet, dass die Gewichte so codiert werden müssen, dass sie von einem genetischen
Algorithmus verändert werden können. Am naheliegendsten ist die Hintereinanderreihung der einzelnen Gewichte (w1 , w2 , ..., wn ). Da diese in der Regel als Gleitkommzahlen repräsentiert werden, könnten sie beispielsweise binär in 20 Bits codiert werden. Zusätzlich zu den Gewichten könnten die Schwellwerte der Neuronen
mitoptimiert und in den Bitstring eingebunden werden.
Bei den genetischen Operatoren sollte das Crossover einzelne Netzparameter
nicht zerschneiden. Dies haben Experimente von Montana und Davis Ende der
1980er ergeben. Das bedeutet, dass die Netzparameter durch Crossover nur vertauscht, nicht aber verändert werden.
Die Veränderung der Gewichts- bzw. Schwellwerte soll einzig und allein durch
Mutation erfolgen. Die Mutation operiert dabei nicht auf der Bitebene der Codierung, sondern direkt auf dem reellen Wert. Dabei wird dem Parameter α mit einer
Wahrscheinlichkeit p (z.B. Mutationrate) die Zufallszahl hinzuaddiert.
5.7 Optimierung neuronaler Netze
54
Eine weitere Aufgabe der Neuroevolution ist die Anpassung der Netztopologie
des kNN.
Laut Rojas ([Roj91]) gibt es noch keinen Vergleich der Leistungen von Lernalgorithmen wie dem Backpropagation und genetischer Optimierung. Für Problemstellungen, zu denen es keine Trainingsdaten für das überwachte Lernen eines
Netzes gibt, ist die Methode der Neuroevolution ein adäquater Ersatz (vgl. [Roj91]
S.392ff, [Rue04] S. 24ff).
6
Open Dynamics Engine
Eine der grössten Herausforderungen dieser Arbeit ist die physikalische Simulation.
Dieser Herausforderung stellt sich Russell Smiths Open Dynamics Engine, kurz
ODE. Dabei handelt es sich um eine frei verfügbare (open source) C-Bibliothek
zur Simulation fester Körper. ODE ist hervorragend geeignet zur Simulation von
Fahrzeugen oder Kreaturen, die sich mit Hilfe von Armen und Beinen fortbewegen.
Und da es ein schnelles und stabiles System ist, ist es ideal, die Ziele, die in dieser
Arbeit verfolgt werden, zu erreichen.
Der Einsatz von ODE in vielen kommerziellen Spielen zeigt, dass es sich hierbei um ein Produkt von hoher Qualität und Stabilität handelt. Daneben wird
ODE häufig für Robotersimulationen verwendet. Auch hier wird die Leistungsfähigkeit dieser Bibliothek deutlich. Denn gerade in der Robotik sind ausgereifte
und realistische Simulationen sehr wertvoll. Auf diese Weise können die Roboter in
Situationen simuliert werden, die für einen praktischen Test zu gefährlich wären.
Oder es können Umgebungen simuliert werden, die im Labor nicht ohne weiteres
herzustellen sind, so z.B. die Mondatmosphäre.
6.1 Eigenschaften von ODE
ODE dient zur Berechnung und Simulation dynamischer Phänomene gegliederter,
fester Körper. Darunter fallen sowohl Fahrzeuge unterschiedlicher Art, die z.B. von
Rädern angetrieben werden können, als auch jegliche Arten von Kreaturen, die sich
mit Armen und Beinen fortbewegen. Natürlich ist es möglich, ODE darüber hinaus
zu verwenden, um andere physikalische Gegebenheiten zu simulieren.
Die äußeren Bedingungen der Umgebung sind vom Benutzer beliebig einstellbar
und können noch während der Simulation verändert werden. Dadurch eignet sich
ODE vor allem für interaktive Echtzeit-Simulationen.
Da physikalische Simulationsumgebungen einen enormen Rechenaufwand in Anspruch nehmen, wurde bei ODE viel Wert auf Geschwindigkeit und Stabilität der
Simulation gelegt und weniger auf physikalische Genauigkeit. In der Regel fallen
diese Ungenauigkeiten nicht auf, es sei denn, ODE wird für quantitative Technik eingesetzt, bei der Berechnungsfehler schlimmere Auswirkungen hätten, als es
beispielsweise bei Computerspielen der Fall wäre.
6.2 Bestandteile von ODE
56
ODE besitzt eine eigene Kollisionsabfrage und -behandlung, wobei es auch
möglich ist, eigene Implementierungen zu verwenden. Die Kollisionsabfrage hat
die Aufgabe, festzustellen, welche Körper sich wie berühren und welche Auswirkungen das auf sie hat. Bei der Implementierung eines Billardspiels würde die
Kollisionsbehandlung feststellen, welche Kugeln sich berühren und wie sich dieser
Zusammenprall auf deren Verlauf auswirkt.
Alles in allem bildet ODE ein Werkzeug zur Berechnung und Simulation dynamischer Umgebungen, wobei die Betonung auf dem Begriff Berechnung liegt.
Die Darstellung der simulierten Körper gehört nicht zu der Aufgabe der Open Dynamics Engine. Hierfür gibt es allerdings zahlreiche Möglichkeiten. So ist es z.B.
möglich die Simulation durch Java3D rendern zu lassen (vgl. [Smi04] S. 1f, 6).
6.2 Bestandteile von ODE
Das Besondere an ODE ist, dass es sehr einfach gehalten ist. Die Bibliothek gliedert
sich im Grunde in zwei Bereiche, die physikalische und die geometrische Welt. Die
physikalische Welt besteht aus:
• World,
• Body,
• Joint und JointGroup;
Die geometrische aus:
• Space,
• Geom,
• Collision Detection.
Was sich hinter den einzelnen Begriffen verbirgt und wie diese zusammenhängen,
wird in den folgenden Abschnitten erklärt. Da ODE in mehrere Programmiersprachen portiert und ein Java-Wrapper in dieser Arbeit verwendet wird, werden die
einzelnen Elemente als Klassen bezeichnet.
6.2.1 World
Das wichtigste Element einer Simulation in ODE ist world. Wie der Name es
schon vermuten lässt, bildet diese Klasse die Welt ab, die simuliert werden soll. In
ihr werden alle anderen Objekte verwaltet. Sollten in einer Anwendung mehrere
Welten erzeugt werden, können sie nicht interagieren.
Neben der Verwaltung der einzelnen Körper besitzt die Welt verschiedene Parameter, die vom Benutzer verändert werden können. Zu diesen Parametern zählt
vor allem die Schwerkraft, die in der Welt vorherrscht, auf der Erde sind dies
g = 9.81 sm2 . Da die Schwerkraft in ODE durch einen Vektor beschrieben wird, würde die Simulation der Erdgravitation durch folgenden Vektor beschrieben werden:


0
g= 0 
−9.81
6.2 Bestandteile von ODE
57
Neben diesem Parameter können Werte, die die Simulation beeinflussen, eingestellt
werden. Hierunter fällt der ERP, der Error Reduction Parameter, der festlegt, wie
stark Fehler korrigiert werden sollen, die durch Berechnungen bezüglich der Gelenke aufgetreten sind. Der Wert kann zwischen 0 (keine Fehlerbehebung) und 1
(Behebung aller Fehler) liegen. Er ist standardmäßig auf 0.2 eingestellt und zeigt
somit erneut, dass ODE eher auf Geschwindigkeit als auf ganz exakte Berechnungen abzielt. Mit dem CFM-Wert (Constraint Force Mixing) können gewisse
Einschränkungen, die für Verbindungen gelten, abgeschwächt werden. Normalerweise sind die Einschränkungen hart“, so sollte in einem Kugelgelenk die Kugel
”
niemals die Pfanne verlassen. Andererseits können solche Einschränkungen abgeschwächt werden, um realere Effekte zu erzielen. Im Falle einer Kollision verhalten
sich die betroffenen Körper ohne Veränderung des CFM wie zwei Stahlkörper und
prallen sofort voneinander ab, ohne sich zu durchdringen. Schwächt man dieses
Verhalten ein wenig ab, können elastische Kollisionen simuliert werden, welche bei
der Berührung von weichen“ Lebewesen, Gummibällen oder ähnlichem auftreten.
”
Die letzte Aufgabe der Welt ist es, den Ablauf der Simulation zu steuern und
schrittweise zu berechnen. Hierzu dienen die Methoden step bzw. quickStep().
Letztere führt zu einer schnelleren, aber weniger genauen Berechnung. Die Schrittgröße in Sekunden und die Anzahl der pro Schritt durchzuführenden Iterationen
bestimmen zusätzlich die Genauigkeit der Simulation (vgl. [Smi04] S. 7ff, 15ff, 41ff,
[DS04] S. 7ff).
6.2.2 Body
Körper werden durch die Body-Klasse beschrieben. Physikalische Eigenschaften eines Körpers sind Masse, Position, Ausrichtung und seine Bewegung. Die Masse
eines solchen Körpers wird einfach durch einen reellen Wert beschrieben, wobei
es zusätzlich möglich ist, den Ort des Masseschwerpunkts festzulegen. Die Position des Körpers, seine lineare Beschleunigung und die Winkelbeschleunigung, die
die Bewegung beschreiben, werden durch Vektoren definiert. Um die Ausrichtung
festzulegen, gibt es mehrere Möglichkeiten:
• Der herkömmliche Weg ist eine Rotationsmatrix, bei der aber das Problem des
Gimbal Locks auftreten kann. Dieser Fehler tritt auf, wenn mehrere Rotationen hintereinander ausgeführt werden. Die Drehung über eine Rotationsmatrix
erfolgt über das lokale Koordinatensystem des zu drehenden Körpers, welches
sich nach der ersten Drehung bereits verändert hat. So kann es sogar vorkommen, dass eine Rotation überhaupt nicht mehr durchgeführt werden kann. Der
Vorteil einer Matrix ist, dass nicht nur Rotationen, sondern auch Transformationen wie z.B. Skalierungen durchgeführt werden können (vgl. [Ebe04b] S. 18,
26).
• Die Verwendung von Achse und Winkel, wobei der Körper um die als Vektor angegebene Achse mit dem gegebenen Winkel gedreht wird. Diese Art der
Rotation ist im Grunde eine Vorstufe zur Quaternionen-Rotation. Die Darstellung von Achse und Winkel erfolgt über ein 4-Tupel bzw. einen 4-dimensionalen
Vektor: (x, y, z, α)T (vgl. [Ebe04b] S. 19f, 26).
6.2 Bestandteile von ODE
58
• Die Rotation mit Hilfe von Quaternionen geht noch einen Schritt weiter. Quaternionen fanden ihren Ursprung vor mehr als 150 Jahren in dem Bereich der
komplexen Zahlen, wobei eine genaue Erklärung hier Fehl am Platz ist. Die
Haupteigenschaft der Quaternionen ist ihre Repräsentation als vierdimensionaler Vektor, wie er bereits für die Achse-Winkel-Rotation verwendet wurde.
Der Unterschied zu der oben erwähnten Methode ist, dass Quaternionen normalisiert werden und untereinander interpoliert werden können (vgl. [Ebe04a]
S. 1ff, [Ebe04b] S. 21ff).
Die geometrische Beschreibung eines Körpers wird durch ein Objekt der Klasse
Geom definiert. Diese geometrische Beschreibung ist notwendig, um z.B. mögliche
Kollisionen zu berechnen, was auch im entsprechenden Abschnitt (6.2.4) beschrieben wird.
Um Körper in Bewegung zu versetzen, ist es möglich, sie Kräften oder Drehimpulsen auszusetzen. Im Falle von Fahrzeugen oder Kreaturen wird allerdings von
dieser Art der Bewegung abgeraten. Dort sollen sogenannte Motoren eingesetzt
werden, die die Gelenke oder Räder in Bewegung versetzen. Hierzu aber mehr im
nächsten Abschnitt (vgl. [Smi04] S. 5f, 19ff, [DS04] S. 10ff).
6.2.3 Joint
Um jeweils zwei Körper miteinander zu verbinden verwendet ODE Gelenke (joints).
Es wird zwischen 7 verschiedenen Gelenktypen unterschieden:
1. Das Kugelgelenk (ball and socket joint) dient zur Verbindung zweier Körper ohne Einschränkung der Freiheitsgrade. Die Position des Gelenks wird
durch seine Ankerkoordinaten festgelegt (siehe auch Abbildung 6.1).
Abbildung 6.1. Kugelgelenk (Quelle:[Smi04] S. 28)
2. Das Achsen- oder Scharniergelenk (hingejoint) besitzt nur einen Freiheitsgrad, der sich auf eine Achse bezieht. Der Vektor, mit dem diese Achse beschrieben wird, kann vom Benutzer festgelegt werden. Abbildung 6.2 zeigt ein
Scharniergelenk mit senkrechter Achse. Die Bewegungsfreiheit der Achse kann
auch eingeschränkt werden, indem Start- und Stopp-Parameter angegeben werden. Diese liegen im Bereich −π bis +π und decken damit die möglichen 360◦
ab.
6.2 Bestandteile von ODE
59
Abbildung 6.2. Achsengelenk (Quelle:[Smi04], S. 29)
3. Die Radaufhängung (hinge2joint) ist prädestiniert für die Simulation von
Fahrzeugen. Sie besteht im Grunde aus zwei hintereinander agierenden Achsengelenken (siehe Abbildung 6.3). Bei der Radaufhängung kann allerdings nur
die erste Achse durch Start- und Stopp-Parameter eingeschränkt werden, die
zweite ist für den Antrieb eines Rads gedacht und kann deshalb immer unbegrenzt gedreht werden.
Abbildung 6.3. Radaufhängung (Quelle:[Smi04] S. 32)
4. Eine Schiebeverbindung (sliderjoint) kann zur Simulation von Kolben oder
ähnlichem verwendet werden. Auch hier wird, wie in Abbildung 6.4 gezeigt,
eine Achse verwendet, um welche die Schiebeverbindung gedreht als auch hin
und her geschoben werden kann. Auch hier können die Grenzen der Verbindung
eingestellt werden.
5. Das Universalgelenk (universaljoint) bietet die meisten Bewegungsfreiräume
neben dem Kugelgelenk. Es besteht aus zwei zueinander senkrechten Achsen,
die beide eingeschränkt werden können (siehe Abbildung 6.5).
6. Eine einfache Verbindung (fixedjoint) zwischen zwei Körpern fixiert diese
aneinander. Da dadurch im Grunde ein neuer einzelner Körper entsteht, ist es
sinnvoller diesen Körper komplett zu definieren, damit das System nicht mit
zu vielen Gelenken rechnen muss.
6.2 Bestandteile von ODE
60
Abbildung 6.4. Schiebeverbindung (Quelle:[Smi04] S. 30)
Abbildung 6.5. Universalgelenk (Quelle:[Smi04] S. 30)
7. Kontaktverbindungen (contactjoint) sind Ausnahmefälle in ODE. Sie werden nicht vom Benutzer erzeugt, sondern während der Simulation bei einer
Kollision, um diese besser beschreiben zu können und evtl. von der Anwendung angepasst zu werden. So können z.B. Reibung, Kräfte, Elastizität oder
der ERP (Error Reduction Parameter) einer Kollision definiert werden (siehe
Abbildung 6.6).
Die Bewegung dieser Gelenke sollte nicht über direkte Kraft- oder Impulseinwirkung erfolgen. Im Gegensatz dazu ist es möglich, die Achsen eines Gelenks jeweils
mit einem sogenannten Motor zu bewegen (siehe Abbildung 6.7).
Die Bewegung wird durch Festlegen einer Geschwindigkeit, mit der sich der Motor drehen soll und der maximal aufzuwendenden Kraft, die eingesetzt werden soll,
um diese Geschwindigkeit zu erreichen, erzeugt. Es ist auch denkbar, Servolenkungen oder -motoren zu simulieren, indem diese Kraft vorher festgelegt wird, was ein
gängiges Verfahren ist. Sollten die Begrenzungen der Gelenke erreicht werden, ist
es für den Motor nicht möglich, das Gelenk über diese Grenzen hinaus zu bewegen.
Zusätzlich können Gelenke in jointgroups verwaltet werden. Diese Gelenkgruppen werden von ODE gezielt bei Kollisionen eingesetzt, damit die Kontaktverbindungen, die in einem Schritt erzeugt werden, gemeinsam gelöscht werden
6.2 Bestandteile von ODE
61
Abbildung 6.6. Kontaktverbindung (Quelle:[Smi04] S. 33)
Abbildung 6.7. Gelenkmotor (Quelle:[Smi04] S. 36)
können. Allgemein lässt sich sagen, dass die Gruppierung von Gelenken vor allem
beim späteren Entfernen von Vorteil ist (vgl. [Smi04] S. 25ff, [DS04] S. 13ff).
6.2.4 Collision Detection
Die geometrische Welt von ODE beschäftigt sich im Wesentlichen mit der Kollisionsabfrage, also der Berechnung, welche Körper sich wann, wo, wie stark berühren
und wie sich diese Kollision auf diese Körper auswirken.
geoms beschreiben das geometrische Aussehen eines Körpers. Neben selbstdefinierten Dreiecks-Netz-Beschreibungen von Geometrien, wie sie häufig in der
3D-Programmierung Verwendung finden, bietet ODE bereits einige Körper, wie
Kugeln, Ebenen oder Quader, an. Mit Hilfe der geometrischen Beschreibung der
Körper ist es letztendlich möglich, zu berechnen, ob es zu Kollisionen kommt oder
nicht.
ODE verwendet Räume“ (spaces), um die Laufzeit der Kollisionsabfrage zu
”
reduzieren. Bei einer Welt bestehend aus N einzelnen Körpern würde die Überprüfung, welche dieser N Körper sich berühren, eine Laufzeit von O(N 2 ) in Anspruch
nehmen. Diese Laufzeit kann durch die Verteilung von Objekten, die sich nicht be-
6.3 ODE in der Praxis
62
einflussen können, in unterschiedliche Räume“ verringert werden. Es werden dann
”
nur noch die Körper gegeneinander geprüft, die sich in einem Raum“ befinden.
”
Alternativ zu den Räumen können Körper Kollisionsgruppen zugeteilt werden,
indem ihnen eine Gruppennummer übergeben wird. Anschließend kann bestimmt
werden, welche Gruppen miteinander kollidieren können und welche nicht.
Im Falle einer Kollision erzeugt das Kollisionsabfrage-System eine Kontaktverbindung, die damit eine Brücke zwischen der physikalischen und geometrischen
Welt bildet (vgl. [Smi04] S. 51ff, [DS04] S. 23ff).
6.2.5 Gesamtsystem
Abbildung 6.8 zeigt das Gesamtsystem von ODE. In der Abbildung wird vor allem
die Verbindung der physikalischen und der geometrischen Welt durch die geometrische Beschreibung (geoms) und die Kontaktverbindungen deutlich (vgl. [DS04]
S. 37ff).
World
Physikalische
Welt
Geometrische
Welt
enthält
Joint
Joint
Joint
enthält
Body
Joint
Joint
verbindet zwei
fasst
mehrere
zusammen
JointGroup
Joint
Space
beschreibt Form
Geom
Joint
Joint
prüft auf
Kollisionen
verbindet
kollidierende
ContactJoint
Joint
Joint
erzeugt
Collision
Abbildung 6.8. ODE Gesamtsystem (Quelle:[DS04] S. 37)
6.3 ODE in der Praxis
Einer der wenigen Kritikpunkte, die dem System vorgeworfen werden können, ist,
dass es keine Einheiten verwendet. Smith rät sogar dazu, Längen und Massewerte
um den Wert 1 zu verwenden. Das ist auch ein Grund, warum ODE nicht unbedingt für Ingenieure geeignet ist. Genau genommen verwendet ODE MKS (Meter,
Kilogramm, Sekunde) als Einheiten, die aber nirgends beschrieben bzw. verfeinert
werden können. Da sich ODE auf einfache physikalische Simulationen spezialisiert
hat, dürften die Angaben in MKS ausreichen. ODE greift bei der Repräsentation
der Zahlenwerte auf den Datentyp FLOAT zurück, was einen Wertebereich von
10−38 bis 1038 ermöglicht.
6.3 ODE in der Praxis
63
Der Benutzer von ODE muss entscheiden, ob seine Anwendung mehr Wert auf
Geschwindigkeit, Stabilität oder auf Genauigkeit legen soll. Die Genauigkeit und
damit die Stabilität kann durch Einstellungen wie dem ERP oder dem CFM, aber
auch durch den Verzicht auf direkte Krafteinwirkung gewahrt werden. Genauigkeit
und Geschwindigkeit stehen häufig in gegenseitigem Konflikt und es gilt, einen
zufriedenstellenden Kompromiss zu finden, bei dem keiner der beiden Faktoren
negativ aus dem Ruder läuft. Um die Geschwindigkeit ohne Genauigkeitsverlust
zu erhöhen, lohnt eine Laufzeitabschätzung, die Smith für eine Gruppe von
• m1 Gelenken mit
• m2 Freiheitsgraden und
• n Körpern
pro Zeitschritt aufgestellt hat. Diese verhält sich ungefähr proportional zu:
O(m1 ) + O(m32 ) + O(n).
Daraus ergibt sich, dass eine Reduzierung der Gelenke bzw. Verbindungen, die auch
bei Kollisionen verwendet werden, als auch eine Verringerung der Freiheitsgrade
nützlich zur Verbesserung der Laufzeit wäre, ohne die Genauigkeit zu beeinflussen.
Aus diesem Grund ist eine Anforderung einer der nächsten Versionen von ODE,
Freiheitsgrade, die in einem Simulationsschritt nicht verändert werden, nicht in die
Berechnungen einzubeziehen (vgl. [Smi04] S. 73ff, [DS04] S. 39).
7
Java3D
Java3D ist eine High-Level-API zum Umgang mit dreidimensionalen Welten. Dabei
ist es zunächst egal, welche Low-Level-API zur tatsächlichen Darstellung verwendet wird. Die Auswahl besteht zwischen Open GL oder DirectX. In beiden Fällen
greift Java3D auf native Funktionen zu. Deshalb ist Java3D auch nicht wirklich
plattformunabhängig einsetzbar, sondern muss in jedem Betriebssystem separat
installiert werden.
Das Spektrum von Java3D reicht von der Darstellung und Interaktion dreidimensionaler Grafiken über die Erzeugung und Bearbeitung dreidimensionaler
Geometrie und deren Rendern bis hin zur Animation der vorliegenden Grafiken.
Damit deckt Java3D alle grundlegenden Bereiche ab, die für eine dreidimensionale Repräsentation nötig sind, zumal es die Möglichkeit gibt, gängige 3D-Formate
wie z.B. VRML einzulesen und darzustellen (vgl. [CS04] S. 4f, [Bou99] S. 1-1ff).
7.1 Der Java3D-Szenengraph
Alle Elemente, die in einer von Java3D dargestellten Welt zusammen kommen,
werden in einer Baumstruktur verwaltet, dem sogenannten Szenengraphen (scene
graph). Elemente, die zur Bildung dieser Struktur eingesetzt werden können, sind:
•
•
•
•
•
•
Geometrie visueller Objekte
Sound
Licht
Position
Orientierung
Aussehen
Auf einige dieser Elemente wird in diesem Kapitel noch näher eingegangen.
Die Ordnung in einer Baumstruktur verlangt, dass jedes Element höchstens
einen Elternknoten besitzt. Diese Einschränkung kann allerdings durch eine Referenzierung zweier Knoten untereinander, die keine Vater-Kind-Beziehung besitzen,
abgeschwächt werden.
Mögliche Elemente des Szenengraphen werden in Abbildung 7.1 dargestellt:
7.1 Der Java3D-Szenengraph
65
Nodes and NodeComponents (object)
Arcs (object relationships)
Virtual Universe
parent-child link
Locale
reference
Group
Leaf
NodeComponent
other objects
Abbildung 7.1. Elemente eines Szenengraphen (Quelle: [Bou99] S. 1-4)
Virtual Universe Die Wurzel des Szenengraphen bildet das VirtualUniverse.
Dieses Element ist vergleichbar mit der World in ODE. Theoretisch ist es möglich mehrere Universen in einer Java3D-Anwendung zu verwenden. Da eine
Kommunikation zwischen diesen Universen von Java3D nicht unterstützt wird,
wird von dieser Möglichkeit abgeraten.
Locale Die eigentliche 3D-Szene geht von dem Locale-Element aus. In der Regel
ist ein Objekt dieses Typs ausreichend, denn durch die Baumstruktur können
von ihm aus alle weiteren benötigten Elemente angehängt werden.
Group Bei dem Element Group handelt es sich um einen Teilbaum, in welchem
die unterschiedlichsten Informationen abgelegt werden können. Ein wichtiger
Vertreter des Group-Elements ist die BranchGroup, die Elemente wie die eigentlichen geometrischen Inhalte oder deren TransformGroups, beinhalten können.
TransformGroups regeln die Positionierung und Orientierung der visuellen Objekte oder der Ansicht des Betrachters auf die vorliegende Szene.
Leaf Am Ende der Hierarchie in einer Baumstruktur stehen die Blattknoten, die
Leaf-Elemente. Vertreter dieses Elementtyps sind die 3D-Objekte, die dargestellt werden sollen oder die Viewplatform, die für die Darstellung der Szene
verantwortlich ist.
NodeComponent Appearance oder Geometry, leiten sich von der Klasse
NodeComponent ab und sind verantwortlich für die Darstellung bzw. die Geometrie der 3D-Objekte. Da die 3D-Objekte schon am Ende der Hierarchie im
Baum stehen, können NodeComponents nur von ihnen referenziert werden.
Ein NodeComponent ist folglich nur eine Erweiterung, eine Komponente eines
Baumknotens.
weitere Objekte Für die eigentliche Darstellung im Rahmen einer grafischen
Oberfläche sind noch weitere Objekte notwendig, die unter diese Rubrik fallen.
7.1 Der Java3D-Szenengraph
66
Die Verwendung dieser Elemente soll durch einen Beispiel-Szenengraphen, wie
er in Abbildung 7.2 zu sehen ist, verdeutlicht werden.
Virtual Universe
Locale
BG
Shape3D node
BG
BranchGroup Nodes
TG
TransformGroup Node
S
View
Appearence
Canvas3D
Screen3D
Geometry
View Platform
Node Components
Physical Body
Physical Environment
Abbildung 7.2. Beispiel-Szenengraph (Quelle:[Bou99] S. 1-5)
Der rechte Teilbaum dieses Beispielgraphen muss nicht explizit vom Entwickler definiert werden. Eine grosse Hilfestellung der Java3D-API ist die Klasse
SimpleUniverse, die diese Arbeit übernimmt. Bei Bedarf können die von SimpleUniverse übernommen Aufgaben, wie das Festlegen der Ansichtsposition, hinterher
noch nach Bedarf angepasst werden.
Ein Szenengraph lässt sich damit in wenigen Schritten erstellen:
1.
2.
3.
4.
5.
Erzeugen eines Canvas 3D-Objekts
Erzeugen eines SimpleUniverse-Objekts, optional dessen Konfiguration
Konstruktion des Inhalts-Teilbaums
Kompilieren des Inhalts-Teilbaums zu einer BranchGroup
Hinzufügen der Inhalts-BranchGroup zu Locale-Objekt
Unter Berücksichtung dieses einfachen Rezepts“ ist die Erstellung von attrak”
tiven Szenen mit Java3D sehr einfach (vgl. [Bou99] S. 1-1ff [CS04] S. 9ff).
Der schwierigste Part stellt die Erzeugung der 3D-Objekte dar. Für dieses Problem stellt Java3D drei Lösungen bereit. Erste einfache Gebilde können durch eine
Kombination der in der Java3D-API angebotenen Formen Kugel, Kegel, Box oder
Zylinder erschaffen werden.
Eine weitere Möglichkeit, die den Benutzer nicht mehr auf diese einfachen Formen einschränkt, ist die Verwendung einer geometrischen Beschreibung der Objekte in Form von Arrays. Diese Beschreibung kann entweder durch Linien oder Punkte oder durch geschlossene Polygonzüge erfolgen. Bei den Polygonen beschränkt
7.2 Interaktion in Java 3D
67
man sich auf Drei- oder Vierecke. Abbildung 7.3 zeigt für jede dieser Möglichkeiten
ein Beispiel.
v0
v1
v2
v4
v3
PointArray
v0
v5
v1
v2
v4
v3
v0
v5
LineArray
v1
v2
v0
v4
v3
v5
TriangleArray
v3
v1
v2
QuadArray
Abbildung 7.3. Geometrien (Quelle:[Bou99] S. 2-26)
Die letzte und einfachste Möglichkeit, statt dem mühsamen eigenständigen
Berechnen der Gitternetzdaten, ist die Verwendung eines 3D-Modellierungs-Programms. Für die Dateiformate vieler gängiger Programme sind sogenannte Loader
für die Java3D-API im Internet zu finden. Diese lesen die in der Modelierungssoftware erstellten Projekte ein und wandeln sie in Java-Objekte um. Die derzeitige
Unterstützung reicht von VRML, dem offiziellen Standard für die Beschreibung
dreidimensionaler Szenen, über Lightwave bis hin zu 3D-Studio Max. Zusätzlich
zu der Festlegung von Körpern bietet Java3D die Möglichkeit, sowohl zwei- als
auch dreidimensionalen Text in die Szenen einzubinden (vgl. [Bou99] S. 2-1ff, 31ff, [CS04] S. 18ff).
Da dreidimensionale Szenen häufig den Anspruch erheben, besonders realistisch
zu wirken, sollte das Aussehen der dreidimensionalen Objekte entsprechend angepasst werden können. Java3D bietet hierzu alle gängigen Methoden. Dabei spielt
der Einsatz von reellen Licht- und Materialeffekten als auch von Texturen eine
wesentliche Rolle. Materialien bestimmen im Wesentlichen, wie sich ein Körper
mit dem vorhandenen Licht in seiner Umgebung verhält: reflektiert er das Licht,
spiegelt sich die Umgebung in ihm? Texturen sind Grafiken, die auf 3D-Objekte
projiziert werden. Dies geschieht je nach Einstellung kachelartig oder die Grafik
wird so verformt“, dass sie das gewählte Objekte komplett einschließt (vgl. [Bou99]
”
S. 6-1ff, 7-1ff, [CS04] S. 62ff).
7.2 Interaktion in Java 3D
In Java 3D wird zwischen Interaktion und Animation unterschieden. Interaktion
beschreibt einen Bildwechsel“ durch eine Aktion des Benutzers. Bei einer Ani”
mation hingegen wird ein solcher Bildwechsel in der Regel durch eine zeitliche
Veränderung ausgelöst.
Beide, sowohl Interaktion als auch Animation, greifen auf das Behavior-Konzept
von Java 3D zurück. Behaviors bieten die Möglichkeit, Eigenschaften des Szenengraphen zu verändern, wobei sie selbst Teil des Graphen sind, denn die Klasse
Behavior ist eine Erweiterung der Klasse Leaf.
Obwohl Java3D nichts mit neuronalen Netzen zu tun hat - hier sei dahingestellt,
ob es sich um natürliche oder künstliche neuronale Netze handelt - bilden die
7.2 Interaktion in Java 3D
68
Behaviors eine Gemeinsamkeit mit ihnen. Ein Behavior lässt sich mit einem Reflex
vergleichen, der bei einem bestimmten Stimulus eine bestimmte Aktion hervorruft.
Mögliche Stimuli von Behaviors sind:
•
•
•
•
Aktionen des Benutzers, z.B. Maus- oder Tastatureingaben
Kollisionen von Objekten
abgelaufene Zeit
Änderung der Ansicht (View Location)
Behaviors verfolgen ein einfaches Konzept, sind dafür aber ein mächtiges Werkzeug, das dem Benutzer bzw. Programmier nahezu alle Möglichkeiten offen lässt.
Sie können verwendet werden, um die Ansicht zu verändern, um z.B. dem Benutzer
immer die beste Sicht zu gewähren oder ihn durch die Szene zu führen oder steuern zu lassen, es können Kollisionsbehandlungen realisiert, Fahrzeuge angesteuert
werden und vieles mehr.
Animationen können in Java3D ebenfalls mit Behaviors realisiert werden. Das
vereinfacht die Arbeit des Java3D-Programmierers ungemein. Er kann damit ein
schon bekanntes Konzept für eine gänzlich andere Aufgabe verwenden. Für Animationen stellt Java3D verschiedene Interpolatoren zur Verfügung, die die Klasse
Behavior bzw. die daraus abgeleitete Klasse Interpolator erweitern. Interpolatoren können dazu verwendet werden, Farbe, Größe, Position oder weitere Eigenschaften von Knoten des Szenengraphen zu verändern. Der hierzu benötigte
Stimulus wird durch die Zeit ausgelöst. Diese zeitlich bedingten Änderungen werden über Alpha-Objekte angesteuert, die die Höhe der Wertänderung und den
dafür vorgesehenen zeitlichen Abstand festlegen. Die Änderung der Werte kann,
wie aus Abbildung 7.4 ersichtlich wird, steigend, fallend oder oszillierend erfolgen.
Abbildung 7.4. Beispiele für steigende, fallende oder unbestimmter Wellenformen
eines Alpha-Objekts (Quelle:[Bou99] S. 5-4)
Eine Änderung der Geometrie, die Morphing genannt wird, ist ebenfalls mit
Java3D möglich. Diese Art der Animation ist sehr beliebt und erlaubt dem Anwender z.B. einen Würfel zu einer Pyramide zu verformen (vgl. [Bou99] S. 5-1ff,
[CS04] S. 54ff).
7.4 Java3D und ODE
69
7.3 Vektormathematik
Ein wichtiger Bestandteil der Java3D-Bibliothek ist das package javax.vecmath.
Hier finden sich viele nützliche Klassen, um Berechnung an und mit Vektoren
durchzuführen, die in der 3D-Programmierung unerlässlich sind.
Die Klassen decken vor allem zwei- und dreidimensionale Vektoren aller primitiver Datentypen (float, double, int) ab und darüber hinaus Vektoren beliebiger
Größe. Auf diesen Vektoren lassen sich Operationen wie Skalierung, Multiplikation,
Normalisierung oder Längenberechnung durchführen.
Neben einfachen Vektoren werden zusätzliche Konstrukte wie Quaternionen,
Achse-Winkel-Darstellung (siehe Unterabschnitt 6.2.2) und Matrizen angeboten,
auf denen die dafür üblichen Operatoren durchgeführt werden können, so z.B.
Matrix-Rotationen, -Transformation, -Negation oder Normalisierung.
Auch odejava, das Bindeglied zwischen der C-Bibliothek ODE und Java, der
Name verrät es bereits, greift auf dieses Paket zurück (vgl. [Bou99] S. 2-15ff, [CS04]
S. 38f).
7.4 Java3D und ODE
Im vorangegangenen Kapitel wurde odejava, die Verbindung zwischen ODE und
Java bereits erwähnt. Dabei handelt es sich um eine Bibliothek, die alle ODEElemente, wie z.B. world oder joint, in entsprechende Java-Klassen packt. Die
Definition einer Simulationsumgebung wird damit äußerst intuitiv und komfortabel. Möglich wird dies durch den Einsatz des Java Native Interfaces (JNI), mit dem
sich native, also plattformspezifische Funktionen aufrufen lassen. Unter Windows
erfolgt dies durch die Einbindung einer DLL (Dynamic Linked Library) und eines
SO (Shared Object) unter Unix/Linux.
Mit diesem Schritt können die physikalische Simulation, deren Berechnungen
und Ergebnisse bereits in Java erfasst werden. Die Darstellung steht demnach
immer noch aus. Da sich dieses Kapitel mit Java3D befasst, liegt es nahe, die Darstellung auch unter Verwendung eben dieser Schnittstelle zu erzeugen. Dies wird
durch zusätzliche Klassen von odejava möglich, die die Objekte der physikalischen
Simulation in den Baum des Szenengraphen einbinden, wobei die geometrische Beschreibung der Körper aus ODE zur Darstellung in Java3D verwendet wird. Diese
geometrischen Beschreibungen werden in TransformGroups aus der Java3D-API
verwaltet und sind damit Teil des Szenengraphen. Das Aussehen dieser Objekte
kann bereits bei ihrer Einbindung festgelegt werden.
Auf diesem Weg sind alle Vorteile der einzelnen Bibliotheken uneingeschränkt
nutzbar. Neben der physikalischen Simulation, die von ODE übernommen wird,
ist es möglich die grafische Darstellung mit Java3D auszuschmücken, um z.B. Hintergrundgrafiken oder Beleuchtung festzulegen.
8
Entwurf
In diesem Kapitel wird der Entwurf des implementierten Systems vorgestellt. Dieser untergliedert sich in die drei Bestandteile: Kreaturen, Simulationsumgebung
und Lernalgorithmen.
8.1 Kreaturen
Die Spezifikation der künstlichen Lebewesen, die im Folgenden als Kreaturen bezeichnet werden, muss folgende Punkte berücksichtigen:
• Es wird eine genetische Beschreibung der Kreaturen benötigt, auf die ein genetischer Algorithmus angewendet werden kann, um sie zu verändern.
• Aus dieser genetischen Beschreibung müssen Java-Objekte generiert werden,
die in die physikalische Simulation eingebunden werden können.
• Die Kreaturen müssen lernfähig sein.
8.1.1 Genetische Beschreibung der Kreaturen
Die genetische Beschreibung der Kreaturen liegt in Form einer Baumstruktur vor.
Die Knoten des Baums stellen die einzelnen Körperteile dar, die Verbindung zwischen ihnen symbolisieren die Gelenke. Einer der Hauptgründe für die Wahl dieser
Repräsentationsform ist die Möglichkeit, eine abgewandelte Form der genetischen
Programmierung zur Evolution der Kreaturen verwenden zu können.
Wichtige Informationen, die die Körperteile betreffen, sind:
• Position,
• Grösse/Ausmaße und
• Drehung.
Position und Grösse werden durch Vektoren beschrieben, die Beschreibung der
Drehung der Körper wird durch Quaternionen realisiert.
Wichtige Informationen für die Definition der Gelenke sind:
• Gelenktyp,
• Lage der Drehachsen,
• Beschränkungen der Achsen und
8.1 Kreaturen
71
• die Positionen, an denen die beiden Körper miteinander verbunden werden.
Als Gelenktypen dienen die verschiedenen joints von ODE, wie Universal- oder
Scharniergelenk oder eine feste Verbindung. Die Lage bzw. die Ausrichtung der
Drehachsen wird durch einen Vektor repräsentiert, die Beschränkungen, also Startund Stoppwerte der Achsen, an denen das Gelenk nicht weiter gedreht werden kann,
sind durch Gleitkommazahlen festgelegt, die von −π bis +π reichen, um die angestrebten Winkel zu beschreiben. Die beiden Verbindungspunkte werden ebenfalls
durch Vektoren definiert. Diese Vektoren beschreiben die relative Ausrichtung eines Ankerpunktes, ausgehend vom Mittelpunkt des Körperteils. Das schränkt den
Wertebereich der Vektorwerte auf [−1, 1] ein, wobei einer der drei Vektorwerte −1
oder 1 sein muss, damit der Ankerpunkt nicht inmitten eines Körperteils liegt.
So beschreibt (−1, 0, 0)T beispielsweise den Ankerpunkt in der Mitte der linken
Seite eines Körperteils oder (0, 1, 1)T die obere, hintere Kante. Diese Art der Beschreibung wird für die beiden zu verbindenden Körperteile verwendet. Damit
die Körperteile nicht ineinander wachsen“, sich also überlappen, wird das in der
”
Baumhierarchie niedrigere Element so gedreht, dass sich die beiden Ankerpunkte
und die daran liegenden Seiten gegenüberstehen.
Als Speicherformat für die genetische Beschreibung wurde XML gewählt. Dies
hat mehrere Gründe. XML-Dateien bilden ebenfalls eine Baumstruktur, die damit äquivalent mit der genetischen Beschreibung der Kreaturen ist. Da XML ein
reines Textformat ist, können Kreaturen relativ einfach manuell erzeugt werden.
Zusätzlich wird XML sehr gut von Java unterstützt und kann schließlich von dem
vorliegenden System einfach eingelesen, manipuliert und gespeichert werden.
Da sich die genetische Beschreibung auf Knoten und Kanten reduziert, genügt es
vollkommen, auch nur diese beiden Elemente in XML abzubilden. Die Knoten werden durch das <segment>-Element, die Kanten durch das <connection>-Element
beschrieben. Die genaue Schema-Definition der XML-Spezifikation findet sich in
Kapitel 9.
Aus dieser XML-Beschreibung lassen sich schließlich Java-Objekte erzeugen.
Wobei für jedes XML-Element eine entsprechende Klasse existiert (Segment bzw.
Connection). Um diese Umwandlung durchzuführen, wäre es theoretisch möglich, ein Data-Binding-Framework einzusetzen (vgl. [McL02] S. 431ff). Auf diesen Schritt wurde in dieser Arbeit allerdings verzichtet. Statt dessen erfolgt die
XML-Erzeugung über eine String-Konvertierung der einzelnen Knoten und ihren
Verbindungen. Hierbei wird, ausgehend vom Wurzelknoten, für jeden Knoten und
jede Verbindung das entsprechende XML-Element erzeugt und abschließend in eine
Datei gespeichert. Anders als bei realen Lebewesen, die über einen größeren Chromosomensatz verfügen, beschränkt sich das Erbgut dieser Kreaturen auf nur ein
einziges Chromosom, in dem alle Informationen enthalten sind, die das Aussehen
einer Kreatur bestimmen. Das Laden eines solchen Chromosoms über eine XMLDatei geschieht über den umgekehrten Weg. Über das Document Object Model
(DOM) wird der XML-Baum eingelesen und aus den einzelnen Elementen werden
die entsprechenden Objekte erzeugt. In Abbildung 8.1 wird die Klassenstruktur
eines Chromosoms deutlich.
8.1 Kreaturen
72
evita.creature
Chromosom
javax.vecmath
Connection
Segment
1
*
-type: int
-highStop1: float
-highStop2: float
-lowStop1: float
-lowStop2: float
axis1
axis2
anchor
Vector3f
+x: float
+y: float
+z: float
position
dimension
anchor
Quat4f
+x: float
+y: float
+z: float
+w: float
rotation
Abbildung 8.1. UML-Beschreibung der Chromosomen
8.1.2 Kreatur-Objekte
Aus den oben beschriebenen Chromosomen können im Folgenden Java-Objekte
der Kreaturen aufgebaut werden. Dies geschieht durch die Klasse Creature, deren
Aufbau stark an die Arbeit mit ODE optimiert ist.
Zur Erzeugung einer Kreatur genügt ein Chromosom, das dem Konstruktor der
Klasse übergeben wird, und ein Name, um die Kreatur von anderen unterscheiden
zu können. Die Kreatur selbst verzichtet auf eine Baumstruktur zur Verwaltung
der Körperteile und Gelenke. Statt dessen werden diese in einfachen Listen organisiert. Der Grund für diesen Schritt liegt in der Arbeitsweise von ODE, das
Körperteile (Body-Objekte) und Gelenke (Joint-Objekte) ebenfalls in Listen verwaltet. Dadurch wird eine spätere Konvertierung vereinfacht.
Die Methode, mit der eine Kreatur denkt“ und handelt, ist nicht im Chromo”
som verankert. Das Chromosom bestimmt lediglich das Aussehen einer Kreatur.
Das Gehirn“, repräsentiert durch die Klasse Brain, wird der Kreatur nach ihrer
”
Erzeugung eingepflanzt“. Das Gehirn lenkt die Kreatur. Es dient damit im Grun”
de als eine Art Steuerung, die die Bewegungen reguliert. Der Unterabschnitt 8.1.4
beschreibt das genaue Vorgehen des Denkens“. Abbildung 8.2 beschreibt den ob”
jektorientierten Entwurf der Kreatur und der damit verbundenen Klassen.
8.1.3 Einbinden in die physikalische Simulation
Die Kreaturen besitzen ausreichende Eigenschaften, um sie physikalisch zu beschreiben. Daher stellt die Einbindung in die physikalische Simulation, die durch
ODE gesteuert wird, kein großes Problem dar. Diese Integration benötigt folgende
Schritte:
8.1 Kreaturen
73
evita.creature
org.odejava
Creature
Body
Joint
*
CreatureJoint
*
Chromosom
Brain
CreatureBody
+think(sensorInput: float[]): float[]
Body1
Body2
-highStop1: float
-highStop2: float
-lowStop1: float
-lowStop2: float
axis1
axis2
anchor
javax.vecmath
Vector3f
+x: float
+y: float
+z: float
position
dimension
Quat4f
+x: float
+y: float
+z: float
+w: float
rotation
Abbildung 8.2. UML-Beschreibung der Kreaturen
1. Jedes Körperteil wird in der Simulation durch ein Body-Objekt repräsentiert.
2. Jedes Gelenk wird durch ein Joint beschrieben.
3. Die Masse m wird rückführend aus Volumen V = l∗b∗h und Dichte % errechnet.
kg
Die Dichte ist konstant 500 m
3 und entspricht somit ungefähr der Dichte von
Holz. Damit berechnet sich die Masse eines Körperteils:
m = % ∗ V = 500 ∗ (l ∗ b ∗ h)
wobei der Masseschwerpunkt der Position des entsprechenden Körperteils entspricht.
Die für die Einbindung einer Kreatur benötigten Klassen sind in Abbildung 8.3
abgebildet. Hervorzuheben sind dabei die Klassen World und Space, in denen die
eigentliche Simulation stattfindet, sowie die Klassen Body und Joint, mit denen die
Kreaturen simuliert werden. Die Klasse OdeBinder erzeugt diese Objekte anhand
der Beschreibung der Kreaturen. Die genaue Vorgehensweise dieser Aufgabe wird
in Abschnitt 9.2 beschrieben.
Abbildung 8.4 stellt den Weg von der XML-Spezifikation der Chromosomen zur
ODE-Repräsentation grafisch dar.
8.1.4 Bewegung und Denken
Die Bewegung der Kreaturen entsteht durch Ausüben einer Kraft auf die einzelnen
Gelenke. Dabei werden, wie im Kapitel 6 beschrieben, keine direkten Krafteinwirkungen, sondern Motoren verwendet. Motoren benötigen zwei Werte, um Bewegung zu erzeugen:
1. eine Geschwindigkeit, mit der der Motor bewegt werden soll und
2. die dazu maximal aufzuwendende Kraft.
8.1 Kreaturen
74
org.odejava
World
Space
Body
evita.ode
Joint
evita.creature
OdeWorld
CreatureBody
+step()
+addCreature(c: Creature)
CreatureJoint
*
*
1
OdeBinder
+bind(w: World, s: Space, c: Creature)
*
Creature
Abbildung 8.3. Klassenübersicht für das ODE-Binding
<segment>
<anchor x="0.0" y="-1.0" z="0.0"/>
<dimension x="1.0" y="1.5" z="0.5"/>
<position x="0.0" y="0.0" z="0.0"/>
<quaternion w="1.0" x="0.0" y="0.0" z="0.0"/>
<connection>...</connection>
</segment>
<connection>
<type>3</type>
<highstop1>1.570796</highstop1>
<highstop2>1.570796</highstop2>
<lowstop1>-1.570796</lowstop1>
<lowstop2>-1.570796</lowstop2>
<axis1 x="1.0" y="0.0" z="0.0"/>
<axis2 x="0.0" y="1.0" z="0.0"/>
<anchor x="1.0" y="0.0" z="0.0"/>
<segment>...</segment>
</connection>
Abbildung 8.4. Von XML nach ODE
Die Richtung der Bewegung wird durch die Geschwindigkeit bestimmt, da sich
diese im positiven als auch im negativen Bereich befinden kann.
Diese beiden Werte werden von sogenannten Effektoren an die physikalische
Simulation weitergegeben. Damit sind Effektoren mit Muskeln natürlicher Lebewesen vergleichbar, die sowohl Kraft als auch Geschwindigkeit festlegen. Für jeden
Freiheitsgrad eines Gelenks ist ein Effektor zuständig.
Im Gegenzug zu den Effektorwerten erhalten die Kreaturen Sensordaten von
der physikalischen Simulation. Diese Sensordaten sind so gesehen die Sinne einer
Kreatur. Sie informieren sie über:
• Winkelstellung und -rate jedes Freiheitsgrades eines Gelenks,
• Bodenkontakt eines Körperteils,
8.2 Die Simulationsumgebung Evita
75
• die Richtung der Kreatur und
• die lineare als auch die Winkelgeschwindigkeit.
Die Sensordaten werden normalisiert, sodass sie im Intervall [−1, 1] liegen. Dies
gilt sowohl für die Winkeldaten als auch für die Richtungs- und Geschwindigkeitsvektoren. Die Kontaktsensoren sind binär, denn ein Körperteil hat Bodenkontakt
oder nicht. Dies wird durch die Werte −1 (kein Bodenkontakt) und 1 beschrieben. Die Einschränkung des Wertebereichs der Sensoren liegt vornehmlich in der
Tatsache, dass zu Beginn dieser Arbeit viele Versuche mit neuronalen Netzen gemacht wurden, die, je nach Aktivierungsfunktion, Werte im Intervall [0, 1] bzw.
[−1, 1] verarbeiten können. Da die Aufgabe eines Netzes bzw. eines Gehirns darin besteht, die Geschwindigkeit eines Gelenkmotors zu bestimmen, und da mit
der Geschwindigkeit auch die Richtung bestimmt wird, werden positive als auch
negative Eingaben benötigt.
Die Sensor- und Effektordaten dienen somit dazu, eine Kommunikation zwischen der Kreatur und ihrer Umgebung zu gewährleisten. Um die eingegebenen
Sensordaten zu verarbeiten und mit entsprechenden Effektordaten darauf zu reagieren, benötigen die Kreaturen ein Gehirn“. Wie ein solches Gehirn arbeitet und
”
lernt, ist zunächst nicht festgelegt, sondern hängt von der Art der Implementierung ab. Hier können Konzepte wie genetische Programmierung, neuronale Netze
oder Fuzzy-Regler eingesetzt werden. Einzige Bedingung ist die Erweiterung der
abstrakten Klasse Brain, bei der die Methode
public abstract double[] think(double[] sensorData);
implementiert werden muss. Als Eingabe erhält diese Methode die von der physikalischen Umgebung abgelesenen Sensordaten. Die Ausgabe wird schließlich über
die Effektoren an die Umgebung wieder zurückgegeben.
8.2 Die Simulationsumgebung Evita
Evita steht für Evolution of intelligent threedimensional animats. Alternativ kann
es auch als E-vita verstanden werden, was einer Verbindung zwischen dem Buchstaben E für Elektronisch und dem lateinischen Wort vita für Leben entspricht.
Evita ist der Name des in dieser Arbeit erstellten Systems zur Simulation der oben
definierten künstlichen Lebewesen.
Damit wäre die erste Aufgabe der Simulationsumgebung bereits im Vorfeld
geklärt. Sie muss in der Lage sein, die Kreaturen einzulesen. Dies kann entweder
durch das Einlesen eines Chromosoms, also der genetischen Beschreibung (siehe
Unterabschnitt 8.1.1) oder durch das Laden einer serialisierten Kreatur erfolgen.
In einem weiteren Schritt werden die physikalische Umgebung erzeugt und deren Eigenschaften definiert. Dabei werden Schwerkraft, Simulationsgeschwindigkeit
und ähnliche Werte eingestellt. Damit der Benutzer diese Einstellungen selbst vor
dem Programmstart festlegen kann, besitzt er die Möglichkeit, diese in einer sogenannten Properties-Datei, die aus Schlüssel-Wert-Paaren aufgebaut ist, festzulegen
und sie dem System zu übergeben.
8.2 Die Simulationsumgebung Evita
76
Nach Erzeugung der physikalischen Umgebung und dem Einlesen oder Erzeugen
der Kreaturen werden diese in die physikalische Welt integriert. Dabei werden zu
allen Körperteilen einer Kreatur ODE-Bodies (siehe Unterabschnitt 6.2.2) und zu
allen Gelenken ODE-joints (siehe Unterabschnitt 6.2.3) erzeugt, auf die die Kreatur
referenziert und die die Kreatur fortan in der physikalischen Umgebung simulieren.
Letzte Aufgabe des Systems ist schließlich die Steuerung der Simulation. Die
Simulation wird schrittweise durchgeführt. Ein solcher Schritt umfasst eine bestimmte Anzahl von Iterationen, die berechnet werden. Wie hoch die Anzahl der
Iterationen pro Simulationsschritt ist, wird im Vorfeld, z.B. über die Properties,
festgelegt. Um sie zu berechnen, bekommt das System eine bestimmte Zeit zur Verfügung, die Schrittweite, die ebenfalls im Vorfeld festgelegt wird. Das System muss
nun diese einzelnen Schritte ansteuern. Hierzu wird ein Controller verwendet, der
dies übernimmt, wobei zwischen einem einfachen und einem 3D-Controller unterschieden wird. Der einfache Controller lässt schlicht nur die physikalische Simulation ablaufen, wo hingegen der 3D-Controller dazu verwendet wird, die Simulation
auch grafisch darzustellen. Neben der Darstellung ist die Geschwindigkeit der grösste Unterschied zwischen beiden Varianten. Die einfache Simulation wird nur durch
die Leistungsfähigkeit des eingesetzten Rechners eingeschränkt. Je schneller dieser
ist, desto schneller wird die Simulation beendet. Der 3D-Controller erlaubt nur 25
Schritte pro Sekunde, was auch der Anzahl Frames in einem Film entspricht, da
das menschliche Auge gar nicht mehr visuelle Veränderungen in dieser Zeit wahrnehmen kann. Welcher der beiden Controller verwendet werden soll, wird beim
Programmstart festgelegt.
Ein Simulationsschritt setzt sich aus folgenden Unterschritten zusammen:
1. Kollisionsabfrage und -behandlung. Hierbei wird geprüft, welche Körper sich
wo berühren und welche Kräfte dabei entstehen. Diese Berührungen werden
gespeichert und können zusätzlich noch einmal explizit abgefragt werden, was
zum Beispiel für die Erzeugung der Sensordaten wichtig ist, um festzustellen,
welche Körperteile Bodenberührung haben.
2. Die physikalischen Berechnungen werden durch die Methode step() oder
stepFast() der Klasse World durchführt. Die zweite Variante arbeitet schneller, ist aber eventuell ungenauer. Die Wahl der step-Methode kann ebenfalls im
Vorfeld festgelegt werden. In diesem Berechnungsschritt wird die vorher definierte Anzahl Iterationen durchgeführt, die die Auswirkungen der Bewegungen
und Kollisionen der Körper bestimmen.
3. Die Effektordaten werden neu berechnet. Hierzu wird die step()-Methode jeder
Kreatur, die sich in der Simulation befindet, aufgerufen. Diese Methode führt
erneut drei Schritte durch:
3.1 Ermitteln der Sensordaten. Dabei werden alle Daten, die eine Kreatur von
dem System erhalten kann, in einem Feld gesammelt. Zu diesen Sensordaten
zählen Richtung, Geschwindigkeiten, Winkelstellungen und -geschwindigkeiten als auch die Information, welche Körperteile den Boden berühren
und welche nicht.
8.3 Der Genetische Algorithmus
77
3.2 Mit der think()-Methode des Gehirns werden die Effektordaten berechnet.
Die Art der Berechnung ist dabei abhängig von der Implementierung der
Brain-Klasse.
3.3 Die Effektordaten werden dem System übermittelt, das daraus die Bewegungen im nächsten Simulationsschritt ermittelt.
4. Abschließend werden die CreatureBody-Objekte der Kreaturen, die die Körperteile beschreiben, mit den Informationen aus der physikalischen Umgebung
synchronisiert. Hierunter fallen Daten wie Position oder Rotation eines Körperteils.
Der 3D-Controller ist mit einem Behavior (siehe Abschnitt 7.2) realisiert worden. Dieser führt in jedem Frame der Szene einen Simulationsschritt durch.
8.3 Der Genetische Algorithmus
Zu Beginn dieser Arbeit sollte der genetische Algorithmus vornehmlich dazu verwendet werden, die Evolution der Morphologie der Kreaturen zu regeln. Doch nach
den ersten Versuchen wurde schnell klar, dass diese Technologie auch für das Erlernen der Bewegungen prädestiniert ist. In der Natur findet sich dieses Prinzip kaum
bis überhaupt nicht. Werden Verhaltensweisen doch eher erlernt anstatt vererbt.
Die Entscheidung, den genetischen Algorithmus auch für das Erlernen der Bewegungen einzusetzen, birgt allerdings nur wenige Schwierigkeiten, da die hierfür
verwendeten Kriterien wie Selektion und Fitnessberechnung in beiden Fällen gleich
behandelt werden können. Zudem kann die für die Bewegung berechnete Fitness
für den genetischen Algorithmus, der die Anatomie bestimmt, verwendet werden.
Einzig die Art der Chromosomenbeschreibung erfolgt auf unterschiedlichen Wegen.
Die Art der Chromosomeninterpretation der Gehirne“ der Kreaturen ist abhän”
gig von ihrer Implementierung und wird in Kapitel 10 näher erläutert. Für die
Veränderung der Anatomie mit Hilfe eines genetischen Algorithmus werden die
Chromosomen der Kreaturen verwendet; da diese in Form einer Baumstruktur
realisiert sind, können sie ohne weiteres mit dem Konzept der genetischen Programmierung (siehe Abschnitt 4.7) entwickelt werden, wodurch sich strukturelle
Änderungen ergeben. Bei der herkömmlichen genetischen Programmierung werden Programmteile oder mathematische Funktionen als Knoten interpretiert. In
diesem Fall stehen die Knoten für Beschreibungen der Anatomie. Der genetische
Austausch über Cross-over oder Mutationen können jedoch auf die gleiche Weise
gestaltet werden (siehe auch Abschnitt 10.3). Einziger Nachteil dieses Vorgehens,
ist eine längere Rechenzeit, die durch die Schachtelung der beiden genetischen
Algorithmen entsteht.
In beiden Fällen durchläuft der genetische Algorithmus eine bestimmte Populationsgrösse über mehrere Generationen hinweg. Die Startpopulation wird in beiden
Fällen zufällig generiert. Auf welche Weise dies geschieht, wird in Kapitel 10 beschrieben. Nach Ablauf einer Generation, in der für jedes Chromosom die Fitness
berechnet wird, die noch verfeinert werden kann (siehe Abschnitt 4.3), wird über
8.3 Der Genetische Algorithmus
78
ein Selektionsverfahren (siehe Abschnitt 4.4) bestimmt, welche Chromosomen zur
Bildung der nächsten Generation verwendet werden. Diese Folgegeneration besteht
dann zum Teil aus Rekombinationen und Mutationen der ausgewählten Individuen.
Um den genetischen Algorithmus durchzuführen, wird ein zusätzlicher Controller benötigt, der die Einstellungen des GAs verwaltet. Hierzu zählen:
•
•
•
•
Art der Selektion
Art der Fitnessberechnung
Anzahl Generationen
Populationsgröße.
In Abbildung 8.5 wird der zeitliche Ablauf eines genetischen Algorithmus beschrieben, mit dem sich ein Bewegungsablauf entwickeln soll. Nach Erzeugung
der initialen Population wird ein neuer Prozess gestartet, der für Simulation und
Evolution einer Generation verantwortlich ist. Dort wird für jedes Individuum eine neue Simulationsumgebung erzeugt; die durch die Selektion generierten und
gespeicherten Chromosomen, die den Gehirnaufbau beschreiben, werden geladen
und bestimmen das Verhalten einer Kreatur, die abschließend bewertet wird. Nach
Ablauf dieses Prozesses wird die Folgegeneration anhand der Bewertung der einzelnen Kreaturen erzeugt, wonach erneut ein Prozess gestartet wird, um diese neue
Generation zu testen und zu bewerten. Dieser Vorgang wird so oft wiederholt, wie
Generationen angesetzt sind.
Der Ablauf des genetischen Algorithmus zur Entwicklung des Körperbaus erfolgt auf die gleiche Weise. Für jedes Chromosom, das die Anatomie einer Kreatur
beschreibt, wird ein genetischer Algorithmus für das verwendete Gehirn gestartet. Die höchste gemessene Fitness dieses Algorithmus wird zur Bewertung des
Chromosoms verwendet.
8.3 Der Genetische Algorithmus
GeneticAlgorithm
79
GeneticAlgorithm
IO
geneticBrainTraining()
initial/next
generation
singleBrainGeneration()
new process
readChromosom()
new(chr)
new()
gensize x
new()
chr : Chromosom
c : Creature
:GAController
addCreature(c)
popsize x
start()
getFitness(c)
saveFitness()
process terminated
Abbildung 8.5. Ablauf eines GA zum Erlernen eines Bewegungsablaufs
9
Implementierung und Test
9.1 XML-Spezifikation
Die Wahl, die Chromosomen der Kreaturen in XML zu verwalten, fiel nicht schwer.
Sie bilden ebenso wie eine XML-Datei eine Baumstruktur. Zugleich ist es relativ
einfach, Chromosomen manuell zu erstellen und auch die Möglichkeiten, XML mit
Java verarbeiten zu können, tragen ihren Teil zu dieser Entscheidung bei.
Wegen des einfachen Aufbaus eines Baumes mit Knoten und Kanten genügt
es auch, nur diese beiden Elemente in XML abzubilden, wobei die wichtigsten
Informationen, um Körper- oder Gelenkeigenschaften zu beschreiben, in die XMLSpezifikation einfließen. Zur Spezifikation des XML-Formats wurde XML-Schema
verwendet, da diese Beschreibung nahezu identisch mit der Klassenbeschreibung
in Java ist. Die Definition der Knoten, die als Segmente bezeichnet werden, ergibt
sich in XML-Schema wie folgt:
< xs : complexType name =" segmentType " >
< xs : sequence >
< xs : element name =" anchor " type =" vectorType "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" dimension " type =" vectorType "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" position " type =" vectorType "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" quaternion " type =" quate rnionTyp e "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" connection " type =" conne ctionTyp e "
minOccurs ="0" maxOccurs =" unbounded "/ >
</ xs : sequence >
</ xs : complexType >
Für die Eigenschaften anchor, dimension und position wird ein vectorType
eingeführt, dessen Spezifikation wie folgt aussieht:
< xs : complexType name =" vectorType " >
< xs : attribute name =" x " type =" xs : float " use =" required "/ >
< xs : attribute name =" y " type =" xs : float " use =" required "/ >
< xs : attribute name =" z " type =" xs : float " use =" required "/ >
</ xs : complexType >
Die Rotation des Körperteils wird durch den Typ quaternionType beschrieben:
< xs : complexType
< xs : attribute
< xs : attribute
< xs : attribute
name =" quaternionTyp e " >
name =" w " type =" xs : float " use =" required "/ >
name =" x " type =" xs : float " use =" required "/ >
name =" y " type =" xs : float " use =" required "/ >
9.2 ODE-Binding
81
< xs : attribute name =" z " type =" xs : float " use =" required "/ >
</ xs : complexType >
Die Verbindungen zu den jeweiligen Kindknoten und die Beschreibung der Gelenke, die diese Verbindungen herstellen, wird durch den connectionType definiert:
< xs : complexType name =" connectionTyp e " >
< xs : sequence >
< xs : element name =" type " type =" xs : int "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" highstop1 " type =" xs : float "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" highstop2 " type =" xs : float "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" lowstop1 " type =" xs : float "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" lowstop2 " type =" xs : float "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" axis1 " type =" vectorType "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" axis2 " type =" vectorType "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" anchor " type =" vectorType "
minOccurs ="1" maxOccurs ="1"/ >
< xs : element name =" segment " type =" segmentType "
minOccurs ="1" maxOccurs ="1"/ >
</ xs : sequence >
</ xs : complexType >
Hier fällt auf, dass auch dieses Element Unterelemente des Typs segmentType
beinhalten kann, wodurch die Baumstruktur gewährleistet wird.
Mit Hilfe dieser Spezifikationen kann nun die gesamte Baumstruktur in XML
abgebildet werden. Das Wurzelelement chromosom definiert sich dann so:
< xs : element name =" chromosom " >
< xs : complexType >
< xs : sequence >
< xs : element name =" segment " type =" segmentType "/ >
</ xs : sequence >
</ xs : complexType >
</ xs : element >
9.2 ODE-Binding
Die Visualisierung der physikalischen Simulation in Java3D wird mit Hilfe der
odejava-Bibliothek ermöglicht. Diese wandelt nicht nur alle Konzepte der CBibliothek in Java-Klassen, sondern ermöglicht auch die Einbindung in Java3D.
Wie in Abschnitt 7.4 bereits beschrieben, werden alle geometrischen Objekte
aus ODE in entsprechende Java3D-Objekte gewandelt. Um diese in jedem Simulationsschritt zu synchronisieren, wird ein DisplayBin verwendet. Ein Objekt dieser
Klasse wird zunächst zur Erzeugung eines OdejavaToJava3D-Objekts verwendet:
DisplayBin boundObjects = new DisplayBin ();
OdejavaToJava3D odejavaToJ3D = new O de j av aT o Ja va 3D ( boundObjects );
Dies geschieht noch, bevor die Geometriedaten übertragen werden. Über das
OdejavaToJava3D-Objekt ist es möglich, die Darstellung der Geometrien festzulegen. Hierzu können eigene Appearence-Objekte angelegt werden, die das Aussehen
9.3 Videogenerierung
82
durch Texturen oder Materialien bestimmen. Anschließend wird die Transformgroup mit den Geometriedaten erzeugt:
odejavaToJ3D . c r e a t e T r a n s f o r m G r o u p s ( world . getGeoms ());
Mit dem Aufruf
J a v a 3 DD i s p l a y O b je c t . addToScene ( boundObjects , scene );
werden die Geometriedaten, die aus der ODE-Umgebung ermittelt wurden, in den
Java3d Szenengraphen eingebunden und im weiteren Verlauf synchron gehalten.
Die Synchronisierung geschieht über den Aufruf
boundObjects . updateAll ();
der nach jedem Simulationsschritt aufgerufen werden muss. Da die Steuerung der
3D-Ansicht über ein Behavior realisiert wird (siehe Abschnitt 8.2) und dieses
jeden Simulationsschritt der physikalischen Umgebung ansteuert, wird auch die
Aktualisierung der 3D-Objekte von dieser Klasse übernommen.
9.3 Videogenerierung
Die Aufnahme von Videos ist ein wichtiger Bestandteil dieser Arbeit. So können
Ergebnisse, ohne das komplette System zur Hand zu haben, verteilt und präsentiert werden. Jedoch ist die Erstellung von Videos weder in ODE noch in Java3D
vorgesehen. Besonders erstaunlich ist das Fehlen einer Schnittstelle zwischen Java3D und dem Java Media Framework JMF, die für diese Aufgabe angebracht
wäre.
Dieses Problem wurde letztendlich durch zwei Schritte gelöst:
1. Speichern der Einzelbilder einer 3D-Simulation und
2. Zusammenführen dieser Bilder zu einem kompletten Film.
Der zweite Schritt stellt das geringere Problem dar, da es viele frei verfügbare
Tools, wie z.B. JPEGVideo 1 gibt, die in der Lage sind, aus einer Liste von Bildern
einen Film zu generieren.
Um zunächst einmal die Einzelbilder der Simulation in Dateien zu speichern,
wird auf ein Konzept der Java3D-Bibliothek zurückgegriffen. Hier kommt ein
Behavior zum Einsatz, das in jedem Schritt das aktuelle Bild extrahiert. Ein solches Behavior, das in Abschnitt 7.2 vorgestellt wird, wird schon für die Steuerung
der 3D-Simulation verwendet, indem es in jedem Frame einen Simulationsschritt
anstößt. Das hier entwickelte ScreenshotBehavior reagiert mit der gleichen Taktrate.
Folgender Code führt die Extrahierung der Bildinformationen des Canvas3DObjekts der Simulation durch:
Gr aph icsC ont ext 3D ctx = c3d . g e t G r a p h i c s C o n t e x t 3 D ();
Raster ras = new Raster ( new Point3f ( -1.0 f , -1.0 f , -1.0 f ) ,
Raster . RASTER_COLOR , 0 , 0 , c3d . getWidth () , c3d . getHeight () ,
new ImageComponent2D ( Image Componen t . FORMAT_RGB ,
1
http://www.ndrw.co.uk
9.4 Realisierung des genetischen Algorithmus
83
new BufferedImage ( c3d . getWidth () , c3d . getHeight () ,
BufferedImage . TYPE_INT_RGB )) , null );
ctx . readRaster ( ras );
BufferedImage img = ras . getImage (). getImage ();
Um die Bildinformationen in ein BufferedImage-Objekt zu stecken, wird zunächst der Graphik-Kontext des Canvas3D-Objekts ausgelesen. Das Canvas3DObjekt ist Teil des Szenengraphen (siehe Abschnitt 7.1) und dient zur Darstellung
der Szene in einer grafischen Oberfläche. Diese Informationen werden auf ein Raster übertragen, das schließlich zur Generierung des Bildes verwendet wird. Dieses
Bild lässt sich nun in eine Datei speichern.
Der Name der Bilder, der Pfad, in dem diese gespeichert werden und ob überhaupt Screenshots in dem aktuellen Ablauf erzeugt werden sollen, werden vom
Benutzer in der verwendeten Properties-Datei festgelegt. Einziger Nachteil dieser
Vorgehensweise ist ein riesiger Geschwindigkeitsverlust, denn die Videogenerierung ist aufgrund des erhöhten Rechenaufwands nicht echtzeitfähig. Der Versuch,
Programme zu verwenden, die unmittelbar Videos eines gewählten Fensters aufnehmen, führte sogar zu noch schlechteren Ergebnissen, da hier nur noch ruckelige
Bruchstücke erfasst wurden.
9.4 Realisierung des genetischen Algorithmus
Die Implementierung des genetischen Algorithmus ist eine der grösseren Herausforderungen dieser Arbeit. Dabei ist ein Problem aufgetreten, das bei der normalen
Verwendung von ODE nicht berücksichtigt werden muss. Durch das mehrmalige Starten der ODE-Umgebung im Rahmen des genetischen Algorithmus, nämlich generationsize ∗ popsize-mal, kam es gehäuft zum Überlaufen der Auslagerungsdatei des Betriebssystems, was zum Abbruch des Programms geführt hat.
Trotz der Aufrufe des Garbage-Collectors oder der Methode Ode.dCloseOde(),
die zu einem Räumen des Speichers führen sollten, trat dieses Problem weiterhin
auf, und erst nach Ablauf des laufenden Prozesses wurde dieser Speicher wieder freigegeben. Das Problem wurde gelöst, indem jede Generation eines genetischen Algorithmus in einem neuen Prozess gestartet wurde. Nach Ablauf dieses mit
Runtime.getRuntime().exec() gestarteten Prozesses wurde die Auslagerungsdatei wieder geleert.
Dieser Umstand hat viel zur Art der Implementierung des genetischen Algorithmus beigetragen. Es musste auf einige Konzepte der objektorientierten Programmierung verzichtet werden. Es wurden weniger Klassen und Objekte zur Berechnung der einzelnen Generation und der Fitness verwendet. Viel mehr wurden die
wichtigsten Informationen wie Fitness oder einzelne Individuen in Dateien gespeichert, um sie nach Ablauf eines Prozesses nicht zu verlieren. Die Fitness wird in
zwei Dateien verwaltet. In einer Datei sind die Fitnesswerte aller Individuen gespeichert, in der anderen wird zur besseren Übersicht nur die Durchschnitts- und
Maximalfitness gespeichert. Diese beiden Dateien liegen im CSV-Format (Comma Separated Values) vor, womit sie ohne weiteres in ein Tabellenkalkulationspro-
9.5 Grafische Benutzeroberfläche
84
gramm eingelesen werden können, in welchem relativ einfach Graphen zur besseren
Übersicht hergestellt werden können.
Für jede Generation wird ein Ordner angelegt, in dem die einzelnen Individuen
bzw. deren Gehirne serialisiert werden. Dadurch ist es auch später möglich, ein
bestimmtes Individuum einer Generation zu laden und zu testen. Die Wahl, nur das
Gehirn zu serialisieren und nicht die komplette Kreatur, liegt in der Vorgehensweise
des genetischen Algorithmus zum Erlernen der Bewegungen. Dieser arbeitet auf
Erweiterungen der Klasse GABrain, welche die abstrakten Methoden
public abstract void crossover(GABrain brain);
public abstract void mutate(double mutationRate);
implementieren. Auf diese Weise ist das Gehirn-Objekt sofort zugänglich und, da
nur ein Teil der Kreatur gespeichert wird, spart dieser Vorgang Speicherplatz.
Um nun ein bestimmtes Individuum einer Generation zu testen, um zu sehen,
wie es sich verhält und wie es zu der erreichten Fitness gekommen ist, genügt es,
eine neue Kreatur mit dem verwendeten Chromosom zu erzeugen, und ihr das
gewünschte Gehirn einzupflanzen“, indem es deserialisiert und der Kreatur mit
”
setBrain() übergeben wird.
Die Selektion der Chromosomen bzw. der Kreaturen, die die nächste Generation
bilden, geschieht über die in Abschnitt 4.4 vorgestellten Verfahren. Welches von ihnen verwendet wird, kann beim Start des genetischen Algorithmus gewählt werden.
Die Implementierung der Selektionverfahren wertet die gemessene oder die erweiterte (siehe Abschnitt 4.3) Fitness aus und erzeugt ein Indexfeld der Individuen,
die zur Bildung der Folgegeneration verwendet werden. Je nach Selektionsverfahren kann es nun sein, dass Individuen mehrfach oder auch gar nicht in diesem
Indexfeld erscheinen. Um eine höhere Vermischung der Gene zu erhalten, wird dieses Feld durcheinander gewürfelt. Anschließend werden die genetischen Operatoren
Crossover und Mutation durchgeführt. Das Durcheinanderwürfeln des Indexfeldes
verringert dabei die Wahrscheinlichkeit, dass zwei identische Chromosomen rekombiniert werden, falls diese ursprünglich hintereinander aufgelistet wurden, was z.B.
beim Stochastic Universal Sampling der Fall wäre.
9.5 Grafische Benutzeroberfläche
Das hier entwickelte System beschränkt sich zunächst nur auf Konsolenanwendungen. Um aber das Erlernen von Bewegungen und später die Ansicht der einzelnen
Resultate ein wenig komfortabler zu gestalten, wurden für diese beiden Anwendungen grafische Benutzeroberflächen gestaltet, die das Anstoßen dieser beiden
Aufgaben erleichtern sollen.
9.5.1 Starten eines genetischen Algorithmus
Zum Start eines genetischen Algorithmus, der zum Erlernen der Bewegungen verantwortlich ist, werden folgende Informationen benötigt:
9.5 Grafische Benutzeroberfläche
•
•
•
•
•
•
•
•
•
85
Name der Kreatur
Pfad des zu trainierenden Chromosoms
Pfad zum Speichern der Ergebnisse
Klassenname des zu verwendenden Gehirns
Anzahl der Generationen
Populationsgröße
Selektionsverfahren
Fitnessfunktion
Mutationsrate
Abbildung 9.1 zeigt die für diese Aufgabe erstellte grafische Oberfläche, mit der
all diese Informationen auf einfachem Wege einzutragen sind. Der Speicherpfad
wird automatisch generiert und setzt sich aus Datum und Uhrzeit zusammen. Die
Wahl des Klassennamens, des Selektionsverfahrens und der Fitnessfunktion wird
durch eine Combobox vereinfacht, in denen die möglichen Alternativen aufgeführt
werden. Die Werte, die durch Zahlen repräsentiert werden, wie Generationenanzahl, Populationsgröße oder Mutationsrate, können durch Spinner eingestellt werden.
Abbildung 9.1. GUI zum Starten eines genetischen Algorithmus
9.5.2 Ansicht der Resultate
Nach Ablauf eines genetischen Algorithmus sollen die erzielten Ergebnisse überprüft werden können. Dazu wird das trainierte Chromosom sowie das zu testende
Gehirn benötigt. In Abbildung 9.2 wird die hierfür erzeugte Oberfläche dargestellt,
die für beide Aufgaben, Wahl des Chromosoms und Wahl des Gehirns, FileChooser
zur Verfügung stellt, die zur grafischen Simulation verwendet werden sollen.
9.6 Tests
86
Abbildung 9.2. GUI zum Starten eines Ergebnisses
Welcher Ordner als Ausgangspunkt der FileChooser verwendet werden soll,
kann beim Programmstart vorgegeben werden. Im Beispiel ist dies D:\logging.
9.6 Tests
Das Testen einer Software nimmt einen immer höheren Stellenwert im Verlauf
des Softwareentwicklungsprozesses ein. Es soll die Qualität der erstellten Software
garantieren (vgl. [Got05]).
9.6.1 Statische Analyse
Die statische Analyse umfasst die Untersuchung des Quellcodes nach möglichen
Fehlerquellen. Dieses Vorgehen wurde ausgiebig während und nach der Implementierung der einzelnen Module angewendet.
In der Regel sollen solche Analysen von Personen durchgeführt werden, die
nicht am Entwicklungsprozess beteiligt sind. Im Falle dieser Arbeit, die nur von
einer Person bearbeitet wird, kann dieser Vorschlag natürlich nicht berücksichtigt
werden.
9.6.2 Testen der Softcomputingverfahren
Dieser Arbeit einer grossen Anzahl Tests zu unterziehen, stellt keine leichte Aufgabe dar. Denn Verfahren wie neuronale Netze oder genetische Algorithmen sind nur
schwer durchschaubar. Wie die erzielten Ergebnisse erreicht werden und wie diese
bewertet werden können, ist fast nicht nachvollziehbar. Dieser Punkt ist jedoch
auch ein großer Vorteil der Verfahren, denn ein Anwender sieht, dass es funktioniert, weiß aber in der Regel nicht, warum. Diese Tatsache unterstreicht, dass für
diese Verfahren nur Blackbox-Tests wirklich sinnvoll sind und auch hier angewendet wurden (vgl. [Got05] S. 7).
So wurden genetische Algorithmen als auch die neuronalen Netze mit einfachen
Aufgaben getestet, wie z.B. das XOR-Problem. Teilaufgaben der einzelnen Technologien wurden vor allem durch Testausgaben und Debugging untersucht, um die
Verfahren im laufenden Betrieb testen zu können.
9.6 Tests
87
9.6.3 Systemtest
Neben den Tests der angewendeten Verfahren wurden die einzelnen Technologien
und deren Kombinationen untersucht. Hierunter fallen Versuche mit ODE, odejava
und Java3D. Diese Tests zielen vor allem auf Leistung ab und konnten zur Verbesserung der Laufzeit und des Speicherverhaltens des gesamten Systems beitragen.
10
Ergebnisse
Dieses Kapitel befasst sich tiefergehend mit den eingesetzten Methoden und den
daraus erzielten Ergebnissen.
10.1 Gehirntypen
Im Laufe dieser Arbeit wurden viele verschiedene Ansätze verfolgt, die Motorik der
Kreaturen anzutreiben. Die Steuerung der Bewegung der Kreaturen steht damit
zunächst im Mittelpunkt. Diese ist von der Arbeitsweise des Gehirns der Kreatur
abhängig, das ja die Aufgabe hat, die aufgenommen Sensordaten auszuwerten, um
damit den momentanen Stand der Kreatur zu erfassen und um daraus Effektordaten zu errechnen, die die Kreatur möglichst effektiv vorantreiben lassen.
10.1.1 Gehirn mit neuronalen Netzen
Die Idee künstliche neuronale Netze (siehe Kapitel 5) zur Simulation eines Gehirns
einzusetzen, liegt nicht fern und wird in dieser Arbeit als erstes angegangen. Dabei
liegt es nahe, die Sensordaten als Netzeingabe zu verwenden und die Effektordaten
aus der Netzausgabe zu gewinnen.
Als nächstes stellt sich die Frage nach der Lernmethode. Hier wird zwischen
den drei Arten:
1. überwachtes Lernen,
2. bestärkendes Lernen und
3. unüberwachtes Lernen
unterschieden.
Das überwachte Lernen ist zwar die gängigste Methode, hier aber schwer oder
unmöglich anzuwenden; denn für diese Art des Lernens werden Trainingsdaten
benötigt, was bedeutet, das die Musterlösung bereits bekannt sein muss, was in
diesem Fall aber nicht zutrifft. Die Aufgabe des Gehirns besteht ja gerade darin,
die bestmöglichen Bewegungsabläufe eines bestimmten Körperbaus zu erlernen.
Im allerersten Ansatz wurde die Methode Trial & Error als Lernmethode angedacht. Diese Art des Lernens ist biologisch sehr plausibel und durchaus vergleichbar
10.1 Gehirntypen
89
mit der Methode, mit der z.B. ein menschliches Baby oder Kleinkind an das Problem der Fortbewegung herangeht. Für diesen Ansatz wurde eine Kombination
aus allen drei Lernverfahren getestet. Mit Hilfe des unüberwachten Lernens sollte
die aktuelle Position des Körpers klassifiziert werden, anschließend sollte eine Bewegung durchgeführt werden, die schließlich durch eine Fitnessfunktion bewertet
wird. Die durchgeführte Bewegung könnte dann ebenfalls durch unüberwachtes
Lernen klassifiziert werden. Diese ersten Schritte beschreiben die Trial-Phase, in
der einfach ausprobiert wird, wie am besten auf die aktuelle Situation eingegangen werden kann. Anschließend könnten gut bewertete Aktionen zu bestimmten
Positionen über überwachtes Lernen trainiert werden. Die Beschreibung verrät es
bereits. Diese Art des Lernens hat zwar seinen Wiedererkennungswert in der Natur, ist aber enorm rechenaufwändig, wenn nicht gar unmöglich durchzuführen.
Die Klassifizierung der Zustände einer Kreatur sprengt allein schon den Rahmen
des Möglichen; denn die Anzahl der erwünschten Klassen bzw. Zustände muss im
Vorfeld festgelegt werden, da diese die Topologie des verwendeten Netzes (SOM,
siehe Unterabschnitt 5.6.3) bestimmen. Würde man beispielsweise die Anzahl der
Sensoren so weit einschränken, dass nur die Winkelpositionen jedes Freiheitsgrades
gemessen werden und hier auch nur das Vorzeichen jedes Winkels berücksichtigt
würde, ergäbe das eine abhängig von der Anzahl Freiheitsgrade dof exponentiell
steigende Anzahl Zustände mit 2dof . Zudem wäre damit nur ein Bruchteil der aktuellen Situation beschrieben. In diesem Fall gäbe es auch keine Möglichkeit, den
Zustandsgraphen zu reduzieren, wie es teilweise im Modelchecking gemacht wird.
Da alle Zustände miteinander verbunden sind, bedeutet das, dass jeder Zustand
jedem anderen folgen oder vorangehen kann.
In Anlehnung an die Arbeit von Gene Ruebsamen ([Rue04]) wurde eine Methode
des bestärkenden Lernens verwendet, die sich Neuroevolution (vgl. Abschnitt 5.7)
nennt. Dabei handelt es sich um eine Kombination aus genetischen Algorithmen
und neuronalen Netzen, wobei die Gesamtheit der Gewichte des Netzes als Chromosom fungiert. Die Bestärkung erfolgt durch die Fitnessfunktion des genetischen
Algorithmus. Für diese Art des Lernens wurden mehrere Netzarchitekturen getestet, von denen sich das Elmannetz (siehe Unterabschnitt 5.6.2) als das geeignetste
erwiesen hat. Einfache vorwärtsgerichtete Netze konnten keine vergleichbaren Ergebnisse erziehlen wie die von Elman entwickelten Netze mit Kurzzeitgedächtnis“.
”
Gehirnaufbau
Der Aufbau des Netzes ist abhängig von der Anatomie der von ihm gelenkten Kreatur. Die Netzeingabe ergibt sich aus der Anzahl der Sensoren, die Netzausgabe aus
der Anzahl der Effektoren. Es wird eine verdeckte Neuronenschicht verwendet,
die zwischen 6 und 10 Neuronen liegt. Die Kontextschicht besitzt genauso viele Neuronen, da sie abhängig von der verdeckten Schicht ist. Ruebsamen hat in
seiner Arbeit mehrere Kontextschichten verwendet, aber Versuche mit einer vergleichbaren Architektur haben gezeigt, dass dabei kein Unterschied zu einfachen
Elman-Netzen zu verzeichnen ist.
10.1 Gehirntypen
90
Genetische Operatoren
Jedes Gewicht des Netzes wird als ein Gen interpretiert, sodass die Gesamtheit
der Gewichte das Chromosom beschreibt. Die Gewichte können hintereinander
aufgeführt als einfache Liste reeller Zahlen interpretiert werden. Dies vereinfacht
die Arbeitsweise der genetischen Operatoren.
So kann der Crossover-Operator in üblicher Weise durchgeführt werden. Um
den positional bias gering zu halten, wird ein Shuffle Crossover durchgeführt, bei
dem vor der eigentlichen Rekombination, für die das One-Point-Crossover verwendet wird, die Reihenfolge der Gene zufällig verändert wird. Im Anschluss an den
Genaustausch wird die ursprüngliche Reihenfolge wieder hergestellt.
Im Falle einer Mutation wäre es z.B. möglich, ein Gewicht durch eine neu errechnete Zufallszahl zu ersetzen. Statt dessen werden die Gewichte bei einer Mutation
nur minimal verändert. Die Höhe der Veränderung wird ebenfalls zufällig ermittelt
und liegt zwischen −0.25 und +0.25.
Zufällige Erzeugung von Gehirnen
Die zufällige Generierung eines Gehirns, also eines Elman-Netzes, ist auch kein
Problem, da die Chromosomen einzig durch die Gewichtungen und die Topologie
definiert sind, also auch die Anzahl der Gene im Vorfeld festgelegt wird. Die Gewichte werden zu Beginn zufällig mit einem Wert, der zwischen −0.5 und +0.5
liegt, initialisiert.
10.1.2 Gehirn mit genetischer Programmierung
Da diese Arbeit sehr stark von der Karl Sims inspiriert wurde, lohnt ein Versuch
der Imitation seiner Nervensysteme“. Ganz exakt wird seine Architektur aller”
dings nicht übernommen, dafür aber die wichtigsten Ideen. Der Genotyp von Sims
Kreaturen wurde für Körperbau und Gehirn gleichermaßen in Form eines gerichteten Graphen beschrieben, wobei beide in gewisser Weise von einander abhängig
sind. Der Aufbau des Nervensystems orientiert sich dabei an dem der Anatomie.
In dieser Arbeit wird zwar auch mit gerichteten Graphen gearbeitet, allerdings
werden diese auf einfache Bäume beschränkt. Auf diese Weise kann auch ohne
Reparaturmechanismen, wie sie bei Sims Methode nötig sind, eine genetische Programmierung durchgeführt werden. In Sims Fall kann es beim Crossover-Operator
zwischen zwei Chromosomen, also Graphen, zu ungültigen Graphen kommen, falls
nötige Verbindungen wegfallen. Danach müssen diese Graphen, ähnlich ihrer zufälligen Erschaffung, nach dem Zufallsprinzip erweitert werden, bis sie wieder einsatzbereit sind.
Die Funktionsweise der genetischen Programmierung wird in Abschnitt 4.7 vorgestellt. Hervorzuheben ist hierbei die Verwendung von Bäumen zunächst unbestimmter Tiefe, anstelle Bitstrings fester Länge. Die Länge der Chromosomen ist
variabel, wird aber auf eine bestimmte Tiefe, z.B. 17 beschränkt.
10.1 Gehirntypen
91
Gehirnaufbau
Dieser Ansatz zielt auf die Berechnung einer mathematischen Funktion, deren
Ausgabe als Effektorwert verwendet wird. Die Berechnung wird mit einem Berechnungsbaum durchgeführt, der später einer genetischen Evolution unterliegt.
Der hier eingesetzte Berechnungsbaum besteht aus zwei Arten von Knoten:
• Berechnungsknoten, die einen oder mehrere Eingänge besitzen, an denen die
Kind-Knoten hängen und einen Ausgang, der sie mit ihrem Eltern-Knoten verbindet oder der als Effektor-Wert verwendet wird, und
• Werteknoten, die ebenfalls einen Ausgang besitzen, jedoch keinen Eingabeknoten, was bedeutet, dass diese Knoten als Blätter im Baum dienen.
Die Berechnungsknoten ermitteln einen mathematische Funktionswert anhand
der von ihren Kind-Knoten erzeugten Eingabe. Die folgende Tabelle (siehe Tabelle 10.1) listet alle verwendeten Berechnungs-Knoten auf:
Name Funktion
Eingabe
+
Summenbildung
2-3
*
Produktbildung
2-3
2-3
max Maximum
min Minimum
2-3
Sinus
1
sin
Cosinus
1
cos
tan
Tangens
1
1
atan Arcus Tangens
abs
Betrag
1
mem Speichert Eingabe für nächsten Zeitschritt 1
Tabelle 10.1. Übersicht der Berechnungsknoten
Als Werteknoten dienen zum einen die Sensordaten, wobei ein Knoten den Wert
eines bestimmten Sensors enthält. Desweiteren werden sogenannte oszillierende
Funktionen verwendet, deren Ausgabe zeitabhängig ist. Tabelle 10.2 zeigt eine
Liste der verwendeten Werteknoten:
Name Funktion
xi
i-ter Sensorwert
coswave coswave(t) = cos(−π + (2 ∗ π)/f req ∗ t)
sinwave sinwave(t) = sin(−π + (2 ∗ π)/f req ∗ t)
saw
saw(t) = −(2/f req) ∗ t + 1
Tabelle 10.2. Übersicht der Werteknoten
Cosinus und Sinus sind Funktionen, die sich in einem Bereich von 2π wiederholen. Hier ist also schon eine Art Oszillation vorhanden. saw ist eine Funktion, die
10.1 Gehirntypen
92
eine abfallende Gerade in einem bestimmten Wertebereich beschreibt. Der Wert
f req legt die Frequenz fest, in der die Funktion oszilliert. t bezeichnet den aktuellen Zeitpunkt, der im Intervall [0, f req] liegt. Ist die Grenze f req erreicht, wird t
wieder auf 0 gesetzt, wodurch die Oszillation zu Stande kommt.
Die Idee für den Einsatz der oszillierenden Funktionen stammt aus der Arbeit
Sims’. Sie dienen als Taktgeber für viele Bewegungen und führen in der Regel zu einem besseren Bewegungsablauf. Erste Versuche ohne solche Funktionen sind nicht
besonders erfolgreich ausgefallen, während mit dem Einsatz dieser Funktionen eine
deutliche Verbesserung der Bewegungsabläufe ersichtlich geworden ist.
Ein Beispiel eines solchen Berechnungsbaums wird in Abbildung 10.1 gezeigt.
Die dort berechnete Funktion lautet:
f (x1 , ..., xn , t) = max(sin(x5 ) + x1 , sin(saw(t)), mem(abs(x3 )))
sin
x5
+
x1
Effektor
max
sin
mem
saw
abs
x3
Abbildung 10.1. Beispiel eines Berechnungsbaums
Das Gehirn einer Kreatur benötigt folglich für jeden Effektor einen solchen
Berechnungsbaum.
Genetische Operatoren
Der Crossover-Operator wird hier für jeden Baum einzelnen angewandt. Das heißt,
zwei Individuen tauschen ihr Erbgut für jeden Effektor separat aus. Der Vorgang
entspricht exakt der in Abschnitt 4.7 eingeführten Art und Weise. Es werden je
zwei Knoten der jeweiligen Bäume ausgewählt und miteinander vertauscht. Da ein
Baum durch diese Methode sehr groß geraten kann, wird eine Höchsttiefe eingeführt, die von dem umgestalteten Baum nicht überschritten werden darf. Deshalb
wird bei der Auswahl der zu tauschenden Knoten darauf geachtet, dass die Bäume
diese Tiefe nicht überschreiten.
10.2 Erlernen eines Bewegungsablaufs
93
Eigentlich wird die Mutation in der genetischen Programmierung nicht eingesetzt. Damit aber auch andere Effektoren einen Nutzen aus guten Berechnungsbäumen ziehen können, können die Bäume eines Gehirns untereinander vertauscht
werden. Die daraus entstehende Reihenfolge wird dem Zufall überlassen. Auch wird
dieser Vorgang nicht in jedem Fall durchgeführt, sondern nur zu einer bestimmten
Wahrscheinlichkeit, die von der Mutationsrate abhängig ist.
Zufällige Erzeugung von Gehirnen
Die Initialpopulation wird durch eine zufällig erzeugte Anzahl Gehirne gebildet.
Das bedeutet, dass jedes Gehirn pro Effektor einen zufälligen Berechnungsbaum
erzeugen muss. Auch hierbei wird eine Höchsttiefe bestimmt, die der zufällig erzeugte Baum nicht überschreiten darf. Dieser Wert liegt in der Regel unter dem
Wert der Höchsttiefe, die beim Crossover-Operator eingehalten werden muss. So
wurde in dieser Arbeit beispielsweise eine initiale Höchsttiefe von 6 und eine Gesamthöchsttiefe von 17 gewählt.
Die Wahl der Knoten wird ebenfalls dem Zufall überlassen. Je tiefer der Baum
wird, desto höher ist die Wahrscheinlichkeit, dass ein Werteknoten gewählt wird.
Wird mit Auswahl des nächsten Knotens eines Teilbaums die initiale Höchsttiefe erreicht, so wird in jedem Fall ein Werteknoten bestimmt, der ein Blatt des
Baumes bildet. Ansonsten wird zunächst entschieden, ob ein Berechnungs- oder
ein Werteknoten gewählt wird, um anschließend den genauen Funktionswert des
Knoten zu bestimmen.
Eine Besonderheit dieser Art der Funktionsgenerierung ist, dass nicht alle, sondern in der Regel sogar nur wenige Eingabewerte die Ausgabe bestimmen. Das
heißt, dass nur wenige Sensordaten zur Errechnung der Effektordaten herangezogen werden. Wie schon erwähnt sorgen meistens die oszillierenden Funktionen für
gute Ergebnisse.
10.2 Erlernen eines Bewegungsablaufs
Nach den Beschreibungen der hier verwendeten Gehirne“ wird schnell deutlich,
”
dass auch für das Erlernen der Bewegungen ein genetischer Algorithmus eingesetzt
werden sollte. Das wichtigste Element des genetischen Algorithmus zur Evolution des Bewegungsablaufs einer Kreatur ist die Fitnessfunktion. Sie beurteilt die
Leistungs- und Überlebenswahrscheinlichkeit eines Individuums.
Da es sich bei der zu messenden Fitness um Bewegungen handelt, liegt es nahe,
die Entfernung, die Geschwindigkeit oder auch die Richtung einer Kreatur in diese
Bewertung einfließen zu lassen. Im Laufe der Zeit wurden mehrere Fitnessfunktionen getestet.
Lineare Entfernung berechnet die zurückgelegte Strecke
xz − xs f it(c) = yz − ys 10.3 Körperevolution
94
xs
xz
wobei
die Startposition und
die Zielposition beschreibt.
ys
yz
Gesamtentfernung summiert die zurückgelegte Entfernung schrittweise. Bei S
Schritten:
S−1 X
xi+1 − xi f it(c) =
yi+1 − yi i=0
Bei dieser Art der Fitnessberechnung werden auch Individuen gut bewertet,
die nicht zielgerichtet in eine bestimmte Richtung wandern, sondern die sich
durchweg viel bewegen.
Gerichtete Fitness ist abhängig von der eingeschlagenen Richtung der Kreatur.
Es sind Bewertungen entlang der X- oder der Y-Achse möglich:
f itx (c) = |xz − xs |
f ity (c) = |yz − ys |
Ruebsamen Fitness Gene Ruebsamen hat dieses Verfahren noch ein wenig verfeinert und eine Bestrafung bei Abweichungen eingeführt:
f itx (c) = 9 ∗ |xz − xs | − |yz − ys |4
f ity (c) = 9 ∗ |yz − ys | − |xz − xs |4
Der Wert 9 wird hierbei als Belohnung, der Wert 4 als Bestrafung verwendet.
Falls der Fitnesswert einen negativen Wert erreicht, wird er auf 0 gesetzt.
Durchschnittliche Entfernung ist eine Erweiterung der Gesamtentfernung. Hier
wird die Gesamtentfernung durch die Anzahl der gemessenen Schritte S berechnet:
S−1
P xi+1 − xi yi+1 − yi f it(c) = i=0
S
10.3 Körperevolution
Die Evolution der Anatomie der Kreaturen wird über Genetische Programmierung
realisiert, wobei die Chromosomen der Kreaturen verwendet werden.
10.3.1 Aufbau der Chromosomen
Der Aufbau der Chromosomen der Kreaturen wird in Unterabschnitt 8.1.1 beschrieben.
10.3 Körperevolution
95
10.3.2 Genetische Operatoren
Der genetische Operator Crossover wird wie in Abschnitt 4.7 beschrieben durchgeführt. Dabei werden zwei zufällige Knoten zweier Chromosomen getauscht, wodurch eine komplett neue Struktur entsteht. Dabei muss der Algorithmus darauf
achten, dass die vorher festgelegte maximale Baumtiefe nicht überschritten wird.
Dies wird durch die Veränderung der Auswahlwahrscheinlichkeit der Knoten in
Abhängigkeit ihrer Tiefe gewährleistet. Dadurch können Knoten, deren Austausch
zu einer zu großen Baumtiefe führt, nicht ausgewählt werden.
Im Falle einer Mutation werden die einzelnen Eigenschaften der Körperteile
bzw. der Gelenke verändert:
•
•
•
•
•
Dimension eines Körperteils
Ankerposition der Nachfolgeknoten
Ankerposition zum Vorgänger- /Elternknoten
Drehachsen
Begrenzungen der Achsen.
Diese Veränderungen sind aber jeweils nur minimal, da die genetische Programmierung allein schon zu einem großen Genpool führt.
10.3.3 Zufällige Erzeugung von Chromosomen
Bei der zufälligen Generierung von Chromosomen sind einige Faktoren zu beachten.
Zunächst ist die Baumtiefe auf den Wert 3 eingeschränkt. Diese Tiefe erhöht sich
in der Regel im Laufe des genetischen Algorithmus. Dann werden die Ausmaße
der Körperteile beschränkt. Die Länge einer Seite liegt im Intervall [0.1, 2.0]. Und
die Begrenzung der Gelenkachsen ist ohnehin auf das Intervall [−π, π] beschränkt,
wodurch die zufällige Generierung dieser Werte ebenfalls dieses Intervall umfasst.
Zuletzt werden die Gelenkachsen zufällig erzeugt. Diese werden durch einen Vektor
gebildet, dessen Werte zwischen −1 und 1 liegen, und der schließlich normalisiert
wird.
10.3.4 Bewertung der Chromosomen
Die Bewertung der Chromosomen, die die Anatomie einer Kreatur beschreiben, ist
relativ umständlich zu ermitteln; zumindest nicht ohne einen erhöhten Rechenaufwand. Um die Fitness eines Chromosoms zu berechnen, muss zunächst ein genetischer Algorithmus durchgeführt werden, der Bewegungen mit dem entsprechenden
Körperbau trainiert. Das bedeutet, dass das Gehirn einer Kreatur, das aus diesem Chromosom entsteht, durch einen genetischen Algorithmus entwickelt wird.
Die dabei maximal erzielte Fitness entspricht der Fitness des Chromosoms. Dieser Umstand führt dazu, dass Chromosomen, mit denen eine gute Fortbewegung
erzielt wird, höhere Chancen haben, in die nächsten Generationen einzufließen.
Desweiteren fällt auf, dass die Fitness eines Chromosoms auch von den berechneten Fitnesswerten des genetischen Algorithmus für die Bewegungserlernung
abhängig ist. Aus diesem Grund ist die Evolution des Körperbaus auch eine sehr
10.4 Bewegen vordefinierter Körper
96
zeitaufwändige Sache. Benötigt der Durchlauf des Gehirntrainings beispielsweise
über 50 Generationen mit einer Populationsgröße von 130 Individuen etwa 20 Minuten, so berechnet sich die Zeit, die der genetische Algorithmus zur Evolution der
Morphologie benötigt:
t = gensize ∗ popsize ∗ 20
Ein Versuch mit 15 Generationen und einer Populationsgröße von 20 würde demnach mehr als vier Tage dauern. Diesem Umstand ist es auch zu verdanken, dass in
dem Bereich der Körperevolution weniger Versuche gemacht wurden und verstärkt
an der Evolution vordefinierter Körper gearbeitet wurde.
10.3.5 Ergebnisse
Versuche, den Körperbau der Kreaturen entwickeln zu lassen, wurden nur wenige
durchgeführt. Die Gründe hierfür sind oben bereits angesprochen worden. Der
Zeitaufwand wurde, vor allem gegen Ende der Arbeit, einfach zu gross.
Wie aus Abbildung 10.2 ersichtlich wird, waren diese wenigen Versuche auch
nicht sehr erfolgreich. Die hierbei entstandenen Kreaturen konnten keine innovativen Bewegungen entwickeln, da ihr Körperbau zu unförmig ausgefallen ist.
Abbildung 10.2. Generierter Körperbau
Um für diese Aufgabe bessere Ergebnisse zu erzielen, wäre eine neue Strategie
von Nöten, mit der die Chromosomen sich erfolgreicher entwickeln könnten. Ein
Ansatz wäre hier z.B., kleine Änderungen an vordefinierten Anatomien vorzunehmen, um diese durch kleine Mutationen zu verbessern. Eine weitere Alternative
könnte eine Menge vordefinierter Körperteile (Beine, Arme, usw.) verwenden, wobei aus diesen, nach dem Baukastenprinzip, neue Kreaturen erstellt und nur komplette Extremitäten durch Crossover ausgetauscht und durch minimale Mutationen
angepasst werden.
10.4 Bewegen vordefinierter Körper
Die meisten Versuche wurden mit vordefinierten Körpern gemacht, die zum Teil
in Anlehnung an Kreaturen anderer Arbeiten erzeugt wurden oder dem Vorbild
verschiedener Tiere nachempfunden sind.
10.4 Bewegen vordefinierter Körper
97
Die in diesem Abschnitt vorgestellten Körperteile sind mit den unterschiedlichsten Gehirnen und Fitnessfunktionen getestet worden. Zur Verbesserung der
Bewegungen wurde an den Stellschrauben des GA-Systems gedreht. So wurden unterschiedliche Selektionsverfahren eingesetzt, die Mutationsrate, Populationsgröße
oder die Anzahl der Generationen verändert.
Im Laufe der Zeit hat sich das Stochastic Universal Sampling (siehe Unterabschnitt 4.4.3) als das zuverlässigste Selektionsverfahren herauskristallisiert. Diese
Methode, ein Eliteauswahlverfahren, spiegelt sich auch in den einzelnen Fitnessverläufen wieder. Es wird deutlich, dass die durchschnittliche Fitness während eines
genetischen Algorithmus zunehmend ansteigt und sich dem Maximum angleicht.
Auch für die Populationsgröße konnte ein Erfahrungswert festgesetzt werden.
Lieferte ein Versuch mit neuronalen Netzen mit noch relativ geringer Populationsgröße, zwischen 70 - 90 Individuen, gute Ergebnisse, benötigte ein Versuch mit
genetischen Algorithmen eine Größe von über 120 Individuen, um vergleichbare
oder bessere Lösungen zu erreichen.
10.4.1 TwoArm
Körperbau
Eine ähnliche Anatomie wie diese findet sich sowohl bei Sims ([Sim94b]) als auch
bei Ruebsamen ([Rue04]). Abbildung 10.3 zeigt den Aufbau der Kreatur, der sich
auf einen Torso und zwei längere Glieder beschränkt.
Abbildung 10.3. TwoArm
Da die beiden Arme jeweils mit einem Universalgelenk an den Torso gegliedert
sind, besitzt die Kreatur vier Effektoren und 16 Sensoren zur Koordination der
Bewegungen.
Verwendete Gehirne
Die besten Ergebnisse mit diesem Körperbau sind mit einem Gehirn nach Unterabschnitt 10.1.2 erzielt worden, das nach der Methode der genetischen Programmierung agiert. Aufgrund der Anzahl der Effektoren werden vier Berechnungsbäume
verwendet.
Auf eine Beschreibung der entwickelten Berechnungsbäume wird hier allerdings
verzichtet. Diese sind in der Regel sehr umfangreich und daher nicht mehr so
10.4 Bewegen vordefinierter Körper
98
einfach nachvollziehbar. Im Grunde liegt - wie bei neuronalen Netzen - eine BlackBox vor. Die Daten lassen sich zwar mathematisch nachrechnen, doch der Grund
für die erzeugte Struktur bleibt dem Benutzer verborgen.
Ergebnisse
Trotz seines einfachen Aufbaus konnte dieser Körperbau, wie kein anderer, nahezu
alle durch die unterschiedlichen Fitnessfunktionen definierten Aufgaben zufriedenstellend bewältigen.
Fitness
Gerichtete Fitness in X-Richtung Eine Bewegung entlang der X-Achse wurde
durch das Anheben eines Arms und dem gleichzeitigen Schlagen des anderen
Arms erreicht, wodurch sich die Kreatur in die Richtung des ausgestreckten
Arms bewegt. Diese Strategie wurde sogar für beide Richtungen, links oder
rechts, angewendet. Abbildung 10.4 zeigt den Fitnessverlauf eines genetischen
Algorithmus mit diesem Ergebnis. Hier sind sowohl rechts- als auch linksgerichtete Bewegungen enthalten.
avg
max
1
11
21
31
41
51
61
71
81
91 101 111 121 131 141 151 161 171 181 191 201
Ge ne ration
Abbildung 10.4. Fitnessverlauf gerichtete Fitness in X-Richtung
Gerichtete Fitness in Y-Richtung Die Bewegung entlang der Y-Achse wurde
durch ein Rudern mit beiden Armen erreicht. Hierbei kam es zwar zeitweise
zu geringen Abweichungen in X-Richtung, die aber wieder ausgeglichen werden
konnten. Der Fitnessverlauf dieses Versuchs ist in Abbildung 10.5 abgebildet.
Ruebsamen Fitness in Y-Richtung Eine interessante Lösung konnte die Kreatur für die Ruebsamen Fitness in Y-Richtung liefern. Bei dieser Art der Fitnessberechnung wird die Abweichung bestraft. Für diese Aufgabe hat die Kreatur die Arme an den Körper angezogen, um gleichmäßig mit ihnen auf den Boden zu schlagen. Durch dieses Verhalten bewegt sich die Kreatur zwar langsam,
99
Fitness
10.4 Bewegen vordefinierter Körper
avg
max
1
12
23
34
45
56
67
78
89 100 111 122 133
Generation
Abbildung 10.5. Fitnessverlauf gerichtete Fitness in Y-Richtung
aber mit nur einer minimalen Abweichung entlang der Y-Achse. Der Fitnessverlauf wird in Abbildung 10.6 dargestellt. In diesem Fall ist die schwankende
Maximalfitness auffallend, die die Probleme unterstreicht, die ein genetischer
Algorithmus mit dieser Art Aufgabenstellung hat.
Fitness
avg
max
1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79
Generation
Abbildung 10.6. Fitnessverlauf Ruebsamen, Y-Richtung
10.4 Bewegen vordefinierter Körper
100
10.4.2 Spinnentiere
Dieser Körperbau ist dem von Spinnen oder Krebsen aus dem Tierreich nachempfunden worden.
Körperbau
In Abbildung 10.7 sind zwei verschiedene Ansätze von Spinnentieren abgebildet.
Bei der zweiten Variante wurde einfach auf die Beine auf einer Seite des Körpers
verzichtet. Um möglichst effektive Ergebnisse einzufahren, sind die Gelenke nur
um eine Achse drehfähig, eingeschränkt durch ein einfaches Scharniergelenk. Auch
die Bewegungsfreiheit wurde im Laufe der Versuche immer weiter eingeschränkt,
um möglichst authentische Bewegungen zu erhalten.
Abbildung 10.7. Spinnentiere
Verwendete Gehirne
Wie mit allen anderen Kreaturen auch wurden für diese Anatomie ebenfalls die
unterschiedlichen Gehirntypen (siehe Abschnitt 10.1) getestet. Erstaunlicherweise scheinen Gehirne, die auf neuronalen Netzen basieren, mit diesem Körperbau
wesentlich besser klar zu kommen, als Gehirne, die das Konzept der genetischen
Programmierung auf Berechnungsbäumen verwenden; die besten Ergebnisse konnten durch Neuroevolution erzielt werden.
Ergebnisse
Aufgrund der anatomischen Einschränkung durch einfache Scharniergelenke konnten auch die Versuche auf Bewegungen in X-Richtung eingeschränkt werden. Hierbei wurde entweder die einfache Entfernung in X-Richtung oder die RuebsamenFitness verwendet. Auch hier finden sich erneut viele interessante Lösungen, die in
der Regel nicht mit den erwarteten Bewegungen vergleichbar sind.
Bei den ersten Versuchen wurde die Bewegungsfreiheit der Gelenke noch nicht
so stark eingeschränkt, was den Kreaturen Raum für individuelle und vielseitig
gestaltbare Bewegungsabläufe ließ. Leider landeten viele dieser Kreaturen auf dem
Rücken oder auf der Seite und haben sich damit selbst bewegungsunfähig gemacht.
Abbildung 10.8 zeigt den Fitnessverlauf eines Versuchs einer Kreatur mit nur
zwei Armen. Statt sich durch Drücken oder Ziehen fortzubewegen, setzt diese Kreatur auf Trippelschritte. Sie streckt die Arme aus und erreicht eine Fortbewegung
10.4 Bewegen vordefinierter Körper
101
Fitness
durch ständiges Hochheben des Torso. Dabei unternimmt sie leichte Ziehbewegungen, denn die Kreatur kriecht in Richtung der Arme.
avg
max
1
4
7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79
Ge ne ration
Abbildung 10.8. Fitnessverlauf Trippelschritte
Fitness
Der in Abbildung 10.9 dargestellte Fitnessverlauf gehört zu einem Versuch mit
einer vierbeinigen Spinne. Diese verhält sich mit den vorderen Beinen ähnlich der
vorher beschriebenen Kreatur, hilft sich aber zusätzlich durch Drückbewegungen
der gegenüberliegenden Beine.
avg
max
1 4
7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79
Ge ne ration
Abbildung 10.9. Fitnessverlauf Trippelschritte und Drückbewegungen
Ein weiterer Versuch mit vier Beinen führte zu einem etwas zufriedenstellenderen Ergebnis. Der Fitnessverlauf dieses Versuchs ist in Abbildung 10.10 dargestellt.
102
Fitness
10.4 Bewegen vordefinierter Körper
avg
max
1
4
7
10 13
16
19 22
25
28
31 34
37
40 43
46
49 52
55
58 61
Ge ne r ation
Abbildung 10.10. Fitnessverlauf krebsgleich
Eine hierbei entwickelte Kreatur arbeitet mit vier angewinkelten Beinen und
bewegt sich durchaus krebsgleich. Allerdings hindert sie sich auch häufig selbst
mit ihren eigenen Bewegungen, so dass diese nicht schneller erfolgt als bei den
anderen. Auffällig an diesem Versuch ist die hohe Maximalfitness in der letzten
Generation. Wäre der Versuch nicht auf 60 Generationen beschränkt gewesen,
hätte hier vielleicht noch eine weitere Verbesserung erfolgen können.
10.4.3 Vierbeiner
Der hier vorgestellte Körperbau lehnt sich an unterschiedliche vierbeinige Tiere
aus der Natur an. Eine solche Versuchsreihe lohnt sich besonders, da viele Vergleichsmöglichkeiten durch Haustiere wie Hunde, Katzen oder Frösche gegeben
sind.
Körperbau
Abbildung 10.11 zeigt unterschiedliche Anatomien, mit denen Versuche gemacht
wurden. Auch hier wurden immer mehr Einschränkungen bezüglich des Bewegungsapparats vorgenommen, um ein immer besseres Ergebnis zu erzwingen; daher
wurden in der Regel nur Scharniergelenke zur Verbindung der Glieder verwendet.
Abbildung 10.11. Vierbeiner
10.4 Bewegen vordefinierter Körper
103
Verwendete Gehirne
Auch diese Art der Anatomie konnte in der Regel bessere Ergebnisse mit Neuroevolution hervorbringen. Es gab zwar auch positive Erscheinungen, die ihre Bewegungen auf die durch genetische Programmierung entwickelten Berechnungsbäume
stützen, aber die besten und effektivsten Fortbewegungsstrategien verwenden neuronale Netze.
Ergebnisse
Fitness
Ähnlich wie bei den Spinnentieren wurden für die Vierbeiner ausschließlich Fitnessberechnungen in X-Richtung vorgenommen. Neben vielen guten Ergebnissen
sind auch diese Kreaturen häufig auf der Seite gelandet, bevor sie es verstanden,
sich sicher vorwärts zu bewegen.
Eine besonders interessante Lösung eines Vierbeiners ist eine rückwärtige Bewegung, deren Fitnessverlauf in Abbildung 10.12 dargestellt ist. Hier konnte die
Kreatur die seitlich liegenden Beine nur nach hinten drehen. Durch anschließendes
Anziehen des Torso kommt die rückwärtige Bewegung zu Stande.
avg
max
1
4
7
10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70
Ge ne r ation
Abbildung 10.12. Fitnessverlauf rückwärtige Bewegung
Aufgrund dieser Erkenntnisse wurde die Bewegungseinschränkung der Beine
nach vorne verlegt, so dass sich die Kreatur auch in die richtige“ Richtung schieben
”
kann. Abbildung 10.13 zeigt den Fitnessverlauf dieses Versuchs.
10.4.4 Sonstige
Im Laufe der Arbeit wurden noch viele weitere Versuche mit allerlei Anatomien
durchgeführt, die scheinbar zu wenig eingeschränkt wurden, zu kompliziert waren
104
Fitness
10.4 Bewegen vordefinierter Körper
avg
max
1
4
7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79
Ge ne ration
Abbildung 10.13. Fitnessverlauf vorwärtsgerichtete Bewegung
oder für die hier eingesetzten Methoden nicht trainierbar sind. Es wurden Versuche mit stark segmentierten Kreaturen gemacht, die an Insekten erinnern oder
Würmern und Schlangen nachempfunden sind. Hierbei sind zwar Bewegungen entstanden, allerdings konnten selbst die besten Individuen dieser Versuche, die ihnen
gestellten Aufgaben nicht zufriedenstellend erfüllen.
11
Zusammenfassung und Ausblick
In dieser Arbeit gab es viele Höhen und Tiefen. Viele Rückschläge, aber auch viele
Fortschritte. Es hat sich gezeigt, dass die Methoden des Softcomputing ihre Grenzen haben, und dass die Simulation von Leben keine einfache Aufgabe darstellt.
Dabei lagen die Ziele dieser Arbeit, vornehmlich gute Bewegungsmechanismen entwickeln zu lassen, noch relativ niedrig. Aber allein die Schwierigkeiten, die sich aus
dieser noch eher harmlosen Aufgabenstellung ergeben haben, zeigen, dass sich auf
diesem Gebiet noch viel tun muss. Es zeigt, dass wir noch weit entfernt von der
Erschaffung künstlichen Lebens sind, wie es sich die anfangs erwähnten Sagen oder
Utopien vorstellen.
Ein kleiner Schritt für eine Kreatur, ein grosser Schritt in Richtung künstliches Leben. Diesen Satz würde ich nur zu gerne unterstreichen, aber es zeigen sich
doch noch erhebliche Schwierigkeiten, die es zu lösen gilt. Komplexe Aufgaben
scheinen für die hier erdachte Art der künstlichen Lebewesen noch nicht möglich
zu sein. Andere Projekte, die die Bewegung ihrer Lebewesen bereits voraussetzen,
konnten schon erste Erfahrungen mit Gruppendynamik, Parasitismus und anderen
Phänomenen, die uns die Natur lehrt, sammeln. Die Welt der dreidimensionalen
künstlichen Lebewesen ist von diesem Schritt wohl noch weit entfernt. Diese Feststellung soll aber nicht entmutigen, den Weg, den Karl Sims begonnen hat, zu
Ende zu gehen. Es zeigt viel mehr, dass hier ein Feld vorhanden ist, das noch nach
vielen Lösungen und Möglichkeiten verlangt.
Ein weiterer Gemeinplatz, der zu dieser Arbeit passt, lautet: Der Weg ist das
Ziel. Denn nie zuvor konnte ich Einblicke in so viele Bereiche der Informatik und
auch außerhalb der Informatik gewinnen. Das Thema künstliches Leben ist breiter gefächert als alle anderen mir bekannten Bereiche der Informatik. Hier hat
mich der Weg von der jüdischen Geschichte über Klassiker der Literatur bis hin zu
modernsten Hollywoodproduktionen geführt. Die Biologie war ein ständiger Begleiter bei der Analyse der genetischen Algorithmen oder neuronalen Netze. Diese
Arbeit hat mir erste Einblicke in die 3D-Programmierung erlaubt, die in meinem
bisherigen Studium nur durch einige Randbemerkungen in der Vektorrechnung
aufgetaucht ist und der ich bisher immer ein wenig skeptisch begegnet bin. Meine
Skepsis behalte ich weiterhin, sehe aber viele Möglichkeiten dieser Technologie, die
zur Zeit vielleicht noch ungenutzt sind. Allein die Lektüre des Buches von Mainzer
([Mai03]) war die Wahl zu dieser Arbeit wert. So diskutiert dieses Buch nicht nur
11 Zusammenfassung und Ausblick
106
Sinn und Unsinn künstlicher Lebewesen oder künstlicher Intelligenz, es fasst auch
das gesamte Studium, das ich an der Fachhochschule genießen durfte, unter dem
Aspekt des künstlichen Lebens zusammen. Dies beweist erneut die hohe Vielfalt
des gewählten Themas, vor allem bezüglich der Informatik. Grundlegende Konzepte, wie die binäre Kodierung und alles, was mit ihr einhergeht, Bäume, Listen
und viele weitere, konnten wiederholt werden. Die Komplexitätstheorie hat mich
ebenfalls ständig verfolgt, bin ich doch über NP-vollständige Probleme wie das
TSP gestolpert und wurde von Zustandsexplosionen überrumpelt. Alles in allem
lässt sich deshalb sagen, dass sich diese Arbeit gelohnt hat. Viel Neues, aber auch
sehr viel Bekanntes ist mir begegnet, was nebenbei zu interessanten und manchmal
auch erheiternden Ergebnissen geführt hat.
Ausblickend lässt sich einiges zu dieser Arbeit sagen, da sich nur die wenigsten
der anfänglich erdachten Ideen umsetzen ließen. Die anfänglichen Schwierigkeiten,
erste brauchbare Ergebnisse zu verzeichnen, und die dadurch fehlende Zeit, haben
mir hier ein Schnippchen geschlagen.
Was ich nur zu gerne gemacht hätte, denn ich bin ein großer Fußballfan, wäre, einen kleinen Bezug zur bevorstehenden Fußballweltmeisterschaft herzustellen.
Im einfachsten Fall könnte ich mir hier eine Art Torwand- oder Elfmeterschießen
vorstellen, bei dem eine Kreatur ein Tor oder ein definiertes Ziel mit einem Ball
treffen muss. Ein Spiel Kreatur gegen Kreatur oder gar ein Mannschaftsspiel zu
simulieren, liegt, nach meinen jetzigen Erfahrungen, wohl noch in weiter Ferne.
Aber zum Glück können sich die Robotiker ja auf diesem Gebiet austoben.
Die Kinderuni wird ein immer beliebterer Termin im Kalender der Fachhochschule. Hier können Schüler aber auch ihre Eltern oder Lehrer Einblicke in die
Arbeit der Studenten in den unterschiedlichsten Fachbereichen sammeln, wodurch
sich die Fachhochschule auch nach außen sehr gut präsentieren kann. Für solche
Termine wäre ein grafischer Editor interessant, mit denen die Schüler ihre eigenen
Kreaturen zusammen bauen könnten und später sehen, wie sich ihre Kreatur im
Vergleich zu denen ihrer Mitschüler entwickelt. Eine ähnliche Idee verfolgt ja bereits der virtuelle Fishtank von Nearlife, der sich im Museum of Science in Boston
befindet.
Eng damit verbunden ist die geometrische Beschreibung der Kreaturen, die
sich bisher nur auf Quader reduziert. Es besteht hier durchaus die Möglichkeit,
beliebig geformte Körper zu entwerfen und sie in der hier erstellten physikalischen
Umgebung zu simulieren. Auch dies wäre mit einem speziellen grafischen Editor
möglich. Diese Arbeit hatte aber das vorrangige Ziel, auch den Körperbau der
Kreaturen der Evolution zu unterwerfen. Wäre die Erzeugung von Bewegungen
oder das Erfüllen einer bestimmten Aufgabe für vorgegebene Körper Ziel dieser
Arbeit gewesen, hätte die Entwicklung eines solchen Editors mit Sicherheit früher
Anklang gefunden.
Aber erst wenn das Erlernen der Bewegungsabläufe kein Problem mehr darstellt, lassen sich andere Aufgaben angehen. Ich denke da weiterhin an Dinge wie
Energiehaushalt, Nahrungsaufnahme, Jagen oder Flüchten, Gruppendynamik und
alles, was damit einhergeht. Ein Schritt in Richtung offene Evolution, die auch in
dieser Arbeit berücksicht werden sollte, aber immer noch in weiter Ferne liegt, wä-
11 Zusammenfassung und Ausblick
107
re vielleicht die Einführung von Trieben, die die Kreaturen zum Handeln bewegen
und die die hier noch verwendete Fitnessfunktion ersetzen würden.
Nicht völlig ohne Ironie und einem Augenzwinkern möchte ich daher diese Arbeit mit den Worten von Ian Malcom aus dem Film Jurassic Park, verkörpert von
Jeff Goldblum, beenden:
Das Leben findet einen Weg.“
”
Literatur
Ada98. Adami, Christoph: Introduction to Artificial Life. Springer/Telos,
1998.
Bou99. Bouvier, Dennis J: Getting Started with the Java 3D API, 1999.
http://java.sun.com/products/java-media/3D/collateral/j3d_
tutorial_ch0.pdf
http://java.sun.com/products/java-media/3D/collateral/j3d_
tutorial_ch1.pdf
http://java.sun.com/products/java-media/3D/collateral/j3d_
tutorial_ch2.pdf
http://java.sun.com/products/java-media/3D/collateral/j3d_
tutorial_ch3.pdf
http://java.sun.com/products/java-media/3D/collateral/j3d_
tutorial_ch4.pdf
http://java.sun.com/products/java-media/3D/collateral/j3d_
tutorial_ch5.pdf
http://java.sun.com/products/java-media/3D/collateral/j3d_
tutorial_ch6.pdf
http://java.sun.com/products/java-media/3D/collateral/j3d_
tutorial_ch7.pdf.
Caw03. Cawsey, Alison: Künstliche Intelligenz - im Klartext. Prentice Hall,
2003.
CS04.
Christopher Schnell, Sascha Strasser: Java 3D - Ein Überblick
der API, 2004.
http://java3d.j3d.org/downloads/Java3D_schnell_tutorial.pdf.
DN94. Detlef Nauck, Frank Klawonn, Rudolf Kruse: Neuronale Netze
und Fuzzy-Systeme. Vieweg, 1994.
DS04. David Schneider, Markus Kettern: Physiksimulation, 2004.
http://www.schneiderlein.com/robotik/Physiksimulation.pdf.
Ebe04a. Ebert, Jens: Quaternionen-Mathematik, 2004.
http://www.games-net.de/resource.php?action=download&id=526.
Ebe04b. Ebert, Jens: Rotationen, 2004.
http://www.games-net.de/resource.php?action=download&id=525.
Literatur
Eid05.
GC02.
Got05.
HB89.
IG04.
JS91.
Kin96.
Mai03.
Mar05.
McL02.
MCV01.
Roj91.
Rue04.
Sim94a.
Sim94b.
Smi04.
Thr94.
Wol02.
Zel94.
109
Eiding, Joachim: Künstliche Intelligenz - Kleinstroboter können sich
nach Vorbild der DNA replizieren, 2005.
http://www.heise.de/tp/r4/artikel/21/21076/1.html.
George Coulouris, Jean Dollimore, Tim Kindberg: Verteilte
Systeme - Konzepte und Design. Addison-Wesley, 2002.
Gottwald, Tim: Dynamisches Testen, Januar 2005. Seminararbeit
Softwarequalitätsmanagement, Fachhochschule Trier.
Horst Bayrhuber, Ulrich Kull, Ulrich Bäßler Albert Danzer: Lindner Biologie. Schroedel, 1989.
Ingrid Gerdes, Frank Klawonn, Rudolf Kruse: Evolutionäre Algorithmen. Vieweg, 2004.
Jeanette Stanley, Evan Bak: Neuronale Netze - Computersimulation biologischer Intelligenz. Systhema, 1991.
Kinnbrock, Werner: Künstliches Leben - Anspruch und Wirklichkeit.
Oldenbourg, 1996.
Mainzer, Klaus: Computerphilosophie. Junius, 2003.
Marbach, Daniel: Evolution and Online Optimization of Central
Pattern Generators for Modular Robot Locomotion, 2005.
http://birg.epfl.ch/webdav/site/birg/users/136698/public/
Master/Master%20Thesis%20Marbach.pdf.
McLaughlin, Brett: Java & XML. O’Reilly, 2002.
Mihai-Christian Varcol, Holger Türk, Volker Strunk Daniel Sawitzki André Roß Michael Gregorius Abdeladim Benkacem Christian Aue Salah Raiyan Abdallah: Simulator für GPevolvierte Laufrobotersteuerungsprogramme, 2001.
http://sigel.sourceforge.net.
Rojas, Raùl: Theorie der neuronalen Netze - Eine systematische Einführung. Springer, 1991.
Ruebsamen, Gene: Evolving Efficient Locomotive Strategies in Embodied Agents, 2004.
http://www.erachampion.com/ai/src/embodied_agents.pdf.
Sims, Karl: Evolving 3D Morphology and Behavior by Competition. Seiten 28–39. Artificial Life IV Proceedings, 1994.
Sims, Karl: Evolving Virtual Creatures. Seiten 15–22. Computer Graphics (Siggraph ’94 Proceedings), 1994.
Smith, Russel: Open Dynamics Engine v0.5 User Guide, 2004.
http://ode.org/ode-latest-userguide.pdf.
Thro, Ellen: Künstliches Leben - Eine spielerische Entdeckungsreise.
Addison Wesley, 1994.
Wolfram, Stephen: A new kind of science. Wolfram Media, 2002.
Zell, Andreas: Simulation Neuronaler Netze. Addison-Wesley, 1994.