Nat¨urliche Beispiele von Multiagentensysteme Utz J.Pape 11. Mai 2003

(1)

Nat¨urliche Beispiele von Multiagentensysteme

Utz J.Pape 11. Mai 2003

Inhaltsverzeichnis

1 Einf¨uhrung 1

1.1 Beispiel . . . 1

2 Nat¨urliche Agentensysteme 2 2.1 Schw¨arme . . . 2

2.1.1 Ziel / Anwendung . . . 2

2.1.2 Regeln . . . 2

2.1.3 Simulation . . . 3

2.1.4 Umsetzung . . . 3

2.2 Einkesselung . . . 4

2.2.2 Regeln . . . 4

2.2.3 Formalisierung . . . 5

2.2.4 Berechnung . . . 5

2.2.6 Umsetzung . . . 6

2.3 Termiten-Nest-Bau . . . 8

2.3.2 Regeln . . . 8

2.4 Aufgabenteilung . . . 8

2.4.2 Regeln . . . 9

2.4.3 Formalisierung . . . 9

2.4.4 Berechnung . . . 9

2.4.6 Umsetzung . . . 11

3 Appendix 12 3.1 matlab code . . . 12

3.1.1 flock ex.m . . . 12

3.1.2 wolf ex.m . . . 14

3.1.3 wasp ex2.m . . . 17

1 Einf¨ uhrung

Als K¨onig Solomon eine Schlacht beobachtete, war er beeindruckt von der Art des Zusammenspiels der einzelnen Armeeteile. Die autonomen Teile, die eine ganzheitliche Aufgabe effizient erf¨ullen konnten.

Um hochkomplexe Systeme zu simulieren, werden diese heutzutage durch kleine autonome Teile (Agenten), deren Verhalten durch simple Regeln vorgegeben ist, realisiert. Dabei nutzt man die

(2)

Emergenzeigenschaft derartiger Systeme aus, um die Funktionalit¨at des hochkomplexen Systems zu erhalten.

Da in der Natur viele Agentensysteme vorhanden sind, versucht man die evolution¨are Erfah- rung, die in diesen Systemen steckt, zu extrahieren, und so diese Konstruktionsprinzipien auf die Problemstellungen anzuwenden. In dieser Ausarbeitung werden vier Beispiele nat¨urlicher Agen- tensysteme besprochen.

1.1 Beispiel

Beobachtet man Ameisen bei ihrer Futter-Suche, so stellt man fest, dass nach kurzer Zeit optimale Wege vom Nest zu den Futterquellen existieren. Mathematisch gesehen handelt es sich um einen minimal aufspannenden Baum, bei dem das Nest und die Futterquellen die Knoten und die Amei- senstraßendie Kanten sind. Allerdings wird wohl kaum eine Ameise einen minimal aufspannenden Baum berechnen k¨onnen, es stellt sich also die Frage, wie diese optimalen Wege entstehen.

Mit einer Modellierung als Multi-Agent-System (MAS) ist es gelungen, die Futter-Suche der Ameisen zu simulieren. Agenten sind dabei natürlich die Ameisen, wobei jede für sich folgende fünf Regeln befolgt:

1. Weiche Hindernissen aus

2. Wandere zuf¨allig in der Gegend herum, wenn Duftstoffe in der N¨ahe vorhanden sind, favo- risiere diese Richtung

3. Wenn Nahrung getragen wird, hinterlasse Duftstoffe und gehe in Richtung des Nest-Duftstoffes.

4. Wenn Nahrung getragen wird und Ameise sich im Nest befindet, lasse die Nahrung fallen 5. Wenn keine Nahrung getragen wird, die Ameise sich nicht im Nest befindet und Nahrung

sieht, nimm diese Nahrung auf

Dabei k¨onnen Ameisen sich fortbewegen, Duftstoffe registrieren und produzieren und Nahrung tragen. Die Umwelt ist charakterisiert durch Nahrungsstellen und einem Nest, dass durch einen einzigartigen Duftstoff gekennzeichnet ist.

Abbildung 1: Pfadsuche bei Ameisen

Wie in Abbildung 1 deutlich wird, laufen die Ameisen zunächst zufällig herum (linke Seite), nach kurzer Zeit jedoch bildet sich durch die Duftstoffe sichtbar gemacht ein klarer optimaler Weg vom Nest zur Nahrung heraus. Dass durch nur fünf Regeln ein derart komplexes Problem in kurzer Zeit gelöst werden kann, regt das Interesse an, Agentensysteme auch für eine Vielzahl anderer komplexer Probleme einzusetzen.

(3)

2 Nat¨ urliche Agentensysteme

Bei den nun folgend vorgestellten Agentensystemen handelt es sich um:

• Schw¨arme

• Einkesselung

• Termiten-Nest-Bau

• Aufgabenteilung

Soweit Simulationsprogramme¹ dazu erstellt wurden, werden diese kurz besprochen und die Ergebnisse pr¨asentiert.

2.1 Schw¨ arme

2.1.1 Ziel / Anwendung

Schwärme von Fischen und auch Vögeln sind in der Lage, Hindernissen auszuweichen und ein gemeinsames Ziel anzusteuern. Dabei gibt es weder viele Unfälle innerhalb des Schwarms, noch löst sich der Schwarm auf bzw. kommen mehrere Individuen abhanden. Wie ist das möglich ohne eine zentrale Steuerungsinstanz?

Ahnliche Probleme treten z.B. bei der Flugsteuerung und auch bei der Steuerung von Schiff-¨ konvois auf. Nach Adaption an das neue Problem besteht die Möglichkeit, dass ein ähnliches Agentensystem auch diese Probleme lösen kann.

Zur Vereinfachung wird das Problam darauf reduziert, dass sich keine Fische aus dem Schwarm ausbrechen und dass keine Kollisionen innerhalb des Schwarms entstehen.

2.1.2 Regeln

Drei Regeln m¨ussen von jedem Fisch (Agenten) befolgt² werden:

1. Halte einen Mindestabstand zu anderen Fischen ein

2. Passe die Geschwindigkeit den Fischen in der Umgebung an 3. Bleibe nahe am Zentrum des Schwarms

Um die Möglichkeiten des Schwarms dahin gehend zu erweitern, er auch Hindernissen auswei- chen und z.B. Nahrung ansteuern kann, müssen folgende drei Regeln hinzugefügt werden:

1. Folge dem Fisch vor Dir

2. Wenn kein Fisch vor Dir ist, steuere die n¨achste Nahrungsquelle an und meide Hindernisse mit einem großen Mindestabstand

3. Wenn ein Hinderniss auftritt, verlangsame Deine Geschwindigkeit und n¨ahere Dich weiter dem Zentrum des Schwarms

Dabei sorgt die letzte Regel daf¨ur, dass Fische am Rande des Schwarms auch nicht gegen ein Hindernis schwimmen.

So wird der Schwarm zu einem sich selbst organisierenden Gebilde.

(4)

−50 −40 −30 −20 −10 0 10 20 30 40 50

−50

−40

−30

−20

−10 0 10 20 30 40 50

flock

x

y

fish

Abbildung 2: Schwarm Initialsisierung

−500 −40 −30 −20 −10 0 10 20 30 40 50

10 20 30 40 50 60 70 80 90 100

flock

x

y

fish

Abbildung 3: Schwarm Endzustand

2.1.3 Simulation

Zu Beginn der Simulation befinden sich 10 Fische nebeneinander (s. Abbildung 2).

Nach etwa 30 Zeitschritten ergibt sich schon ein Schwarm-¨ahnliches Gebilde (s. Abbildung 3).

Da nur die ersten drei regeln implementiert wurden, formiert sich kein symmetrischer, geordne- ter Schwarm, aber trotzdem ist es beeindruckend, dass man mit nur drei Regeln derartige Resultate erhalten kann. Auch nach sehr großen Zeitschritten ist der Schwarm noch immer zusammen.

1S¨amtliche Simulationsprogramme wurden in Matlab 6.1 umgesetzt.

2befolgenist an dieser Stelle nicht ganz korrekt, da - wie wir sp¨ater noch sehen werden - die Agenten nicht durch die Regeln determiniert, sondern stochastisch beschrieben werden.

(5)

2.1.4 Umsetzung

Das Hauptprogramm besteht aus zwei verschachtelten for-Schleifen. Dabei iteriert die äußere Schleife über die Zeitschritte und die innere über die Agenten und bewegt jeden Agenten um einen Zeitschritt. Dieses Konstrukt findet sich bei sämtlichen Simulationen wieder, da eine andere Implementierung als diese komplizierter ist. Sowohl Agenten als auch Umwelt, die es hier nicht gibt, agieren gekoppelt über die diskretisierte Zeit.

Bei einer objektorientierten Implementierung sollte nat¨urlich jeder Agententyp einer Klasse und jeder Agent einem separaten Objekt entsprechen. Da es hier - wie auch bei den anderen Simu- lationen - jedoch nicht um programmiertechnisch beispielhaftes Programmieren ging, sondern nur um Ergebnisse mit vertretbaren Programmieraufwand, finden sich die Agenten und Eigenschaften jeweils in Vektoren.

In jedem Zeitschritt berechnet der Agent zunächst seine Umgebung (get neighbors()), um so seine Geschwindigkeit den übrigen Agenten anzupassen (average speed()). Als nächstes wird für die Richtung des Agenten noch das Zentrum des Schwarms hinzugezogen (get center orientation()).

Nach der Beachtung einiger Restriktionen (z.B. Geschwindigkeitsbegrenzung), werden die neuen Koordinaten berechnet. Diese sind allerdings nicht determiniert, sondern stochastisch (s.rand()).

Damit keine Kollisionen auftreten, überprüft der Agent auf seiner neuen Position, ob in dieser Umgebung (wiederumget neighbors()) schon andere Agenten vorhanden sind. Ist dies der Fall, verringert er seine Geschwindigkeit und überprüft erneut die neue Position. Ggf. bleibt der Agent stehen (z==0).

Natürlich macht die Umsetzung weitere Annahmen wie z.B. dass der Agent die Umgebung um seinen Mittelpunkt herum beobachten könnte. Dies ist in der Natur für Fische nicht möglich. Um dies zu berücksichtigen, müsste get neighbors() komplizierter gestaltet werden. Das Ergebnis würde sicherlich kaum beeinflusst werden.

2.2 Einkesselung

Bei der Einkesselung geht es darum, ein Zielobjekt von allen Seiten zu umstellen. Z.B. Wölfe können alleine keinen Elch reißen, jedoch in einer Gruppe, wenn der Elch umkreist ist, kann ein Wolf seitlich von hinten auf den Rücken des Elchs springen. Dabei stellt sich die Frage, wie die Wölfe die Umzingelung schaffen, ohne dabei zu kommunizieren.

Viele Anwendungen dieses Szenarios finden sich im milit¨arischen Bereich.

2.2.2 Regeln

Da es zwei verschiedene Agententypen gibt, m¨ussen auch zwei Mengen von Regeln gegeben sein.

Der Elch gehorcht dabei nur einer Regel:

1. Maximiere den Abstand zum n¨achsten Wolf

Die W¨olfe m¨ussen versuchen zwei Ziele mit einander zu vereinbaren:

1. Minimiere den Abstand zum Elch

2. Maximiere den Abstand zum n¨achsten Wolf

Letztere Regel ist notwendig, damit die W¨olfe sich nicht selbst gegenseitig behindern.

Man kann leicht sehen, dass diese Strategien jeweils f¨ur die W¨olfe und den Elch optimal sind.

Sind Wölfe und Elch gleich schnell, so werden bei einer Simulation mit diesen Regeln die Wölfe niemals den Elchen fangen. Sind die Wölfe hingegen schneller, so wird der Elch jedesmal gefangen.

(6)

2.2.3 Formalisierung

Wie zuvor betrachtet, lassen sich MAS formalisieren. Dies f¨uhren wir zun¨achst an diesem Beispiel vor:

h{h(p, v, o),(p, o),(p, o),{timestep(τ)}i},h(),{},i,{agents:tb, env:tb}i (1) Das MAS besteht also aus einer Menge von Agenten, einer Umwelt, die aber in unserem Falle leer ist, und einer homodynamischen zeitbasierten Kopplung. Die Agenten haben das Zustand- stupel (p, v, o), dabei steht p für die Position,v für die Geschwindigkeit und o für den Typ des Agenten.

Normalerweise würde man den Typen nicht in den Agenten als Zustand mitführen, da es sich einfach um zwei verschiedene Typen handeln würde, d.h. die Menge der Agenten würde aus zwei Teilmengen bestehen. Da aber hier die Agenten (Wolf und Elch) derart ähnlich sind, bietet sich obige Vorgehensweise an.

Jeder Agent benötigt die Position und den Typ der anderen Agenten, um obige Regeln zu befolgen, daher befinden sich diese jeweils in den Input/Output Tupeln. Die Geschwindigkeit hingegen ist nur intern für jeden Agenten verfügbar.

2.2.4 Berechnung

Der Simulation liegt ein hexagonales Grid zugrunde. Damit ist die Bedingung für eine erfolgreiche Einkesselung, dass der Elch sich nicht mehr bewegen kann, d.h. er von sechs Wölfen umgeben ist. Jeder Agent muss in seinem Zeitschritt ein neues Feld aussuchen. Zunächst werden alle in Betracht kommenden Felder, d.h. jene Felder, die der Agent mit seiner Geschwindigkeit erreichen kann, ausgewählt und für diese ein Score berechnet. Der Agent begibt sich dann auf das Feld mit dem höchsten Score. Die Formeln für den Score lauten:

Swolf =k∗d(nearest wolf)−d(moose) (2)

Smoose=d(nearest wolf) (3)

Dabei ist in Gleichung (2) k eine Abstoßungskonstante zwischen den Wölfen. Diese muss natürlich recht klein sein, so dass immer der Anteil zur Minimierung der Distanz zum Elch über- wiegt.d(◦) ist hier ein Abstandsmaß.

2.2.5 Simulation

Die Simulation beginnt mit der Startformation wie in Abbildung 4 zu sehen.

Die W¨olfe nehmen sofort die F¨ahrte auf und setzen dem Elch nach (vgl. Abbildung 5). Abbil- dung 6 zeigt, wie der Elch nach einigen Zeitschritten umzingelt ist.

Die Statistik in Abbildung 7 gibt Aufschluss über die benötigte Anzahl von Zeitschritten bis die Wölfe den Elch gefangen haben. Aus dieser wird deutlich, dass der Elch immer gefangen wird.

2.2.6 Umsetzung

Wie auch bei dem anderen Simulation, besteht das Hauptprogramm aus den zwei verschachtelten Schleifen. Die Agenten sind auch wieder in Vektoren gespeichert. Dietimestep-Funktion ist hier die get next pos() Funktion. In dieser wird zuerst je nach Typ die Geschwindigkeit ermittelt³. Und anschließend f¨ur jedes Feld, welches mit der berechneten Geschwindigkeit erreicht werden kann, der Score ermittelt (get score()). Das Feld mit dem maximalen Score ist die neue Position des Agenten. Ist der Score mehrerer Felder gleich groß, so wird per Zufall das neue Feld ermittelt (choose rnd()).

3Eleganter w¨are es nat¨urlich, diese in einen extraEigenschafts-Vektor zu speichern, aber der Einfachheit halber wurde darauf verzichtet.

(7)

−25 −20 −15 −10 −5 0 5 10 15 20 25

−25

−20

−15

−10

−5 0 5 10 15 20 25

wolves catch moose

x

y

moose wolf

Abbildung 4: Einkesselung Startzustand

−25 −20 −15 −10 −5 0 5 10 15 20 25

−25

−20

−15

−10

−5 0 5 10 15 20 25

wolves catch moose

x

y

moose wolf

Abbildung 5: Einkesselung w¨ahrend des Laufs

Die Koordinaten des hexagonalen Grids bestehen aus einemxund einemy Wert. Dery Wert, der die Zeile angibt ist fortlaufend. Der x Wert l¨auft jedoch pro Zeile in zweier Schritten. D.h.

die x-Werte der 0. Zeile enthalten nur ungerade Zahlen, die der 1. Zeile nur die geraden Zah- len, die der 2. Zeile wiederum die ungeraden Zahlen usw. Dadurch wird zwar die Berechnung und die Distanzmessung etwas komplizierter, jedoch ist f¨ur die Darstellung so keine Umrechnung notwendig.

Die Schleife im Hauptprogramm bricht ab, wenn die maximale Anzahl an Zeitschritten erreicht wurde, oder der Elch gefangen wurde (moose caught()). Letztere Funktion berechnet den Abstand von jedem Wolf zum Elch, wenn jeder Abst¨ande exakt 1 ergibt, dann ist der Elch gefangen. Dies wurde der Einfachheit und der Schnelligkeit wegen so realisiert, werden mehr als sechs W¨olfe eingesetzt, funktioniert dies so nicht mehr. Dann muss abgefragt werden, ob alle Positionen um den Elch herum schon besetzt sind (was aber zeitaufwendiger ist).

(8)

−25 −20 −15 −10 −5 0 5 10 15 20 25

−25

−20

−15

−10

−5 0 5 10 15 20 25

wolves catch moose

x

y

moose wolf

Abbildung 6: Einkesselung Endzustand

0 10 20 30 40 50 60 70 80 90 100

0 10 20 30 40 50 60 70

number of steps for surroundings

timesteps

#surroundings

Abbildung 7: Einkesselung Statistik

2.3 Termiten-Nest-Bau

Termiten bauen atemberaubende Nester. Diese sind z.T. mehr als 5m hoch, mehr als 10t schwer und älter als 350 Jahre. Allerdings existiert kein Architekt. Es gibt keine Termite, die den anderen Termiten Anweisungen gibt. Als Agentensystem organisiert, werden jedoch wieder nur wenige Regeln benötigt, um solche stabilen und großen Gebäude bauen zu können.

Ob man die hieraus gewonnenen Erkenntnisse nutzen kann, um möglicherweise künstliche Agenten-Bauarbeiter-Manschaften zu konstruieren, ist fraglich. Aber schon die Vorführung als Beispiel dient zum Zeigen der Anwendungsbreite von Agentensystemen.

2.3.2 Regeln

Die Agenten m¨ussen drei Regeln erf¨ullen:

(9)

1. Produziere Bau-Material mit Duft 2. Wandere zuf¨allig, bevorzuge Duftrichtung

3. Entscheide stochastisch ¨uber Material-Abwurf abh¨angig von:

• Duftkonzentration

• getragenem Bau-Material

Simulationen zeigen, dass zunächst eine gleichmäßige Punktverteilung der Materialien zustan- den kommt. Diese Punkte werden zu Säuzlen erhöht, da die Duftkonzentration in der Mitte eines jeden Punktes am größten ist. Dadurch dass die Säulen aber ein wenig zur Seite geneigt (auf Grund des stochastischen Charakters der Regeln) sind, werden die Säulen auf einer bestimmten Höhe durch Bögen miteinander verbunden. Denn sobald die Neigung einer Säule diese selbst so nahe an eine andere Säule nähert, wird auch die Duftkonzentration der benachbarten Säule in die stochastische Berechnung einbezogen, so dass der neigende Effekt verstärkt wird und in besagten Bögen mündet. Da alle Säulen derartig mit einander verbunden werden, entsteht so ein neues Stockwerk. Auf diesem erfolgt der Bau der Säulen auf gleichem Wege.

An diesem Beispiel wird besonders deutlich, dass es sehr viele freie Parameter gibt, u.a.:

• Wie weit reicht die Duftkonzentration?

• Wie stark beeinflußt die Duftkonzentration den Abwurf des Materials?

• Wieviel Zufall ist im Spiel?

• Wieviel Material wird auf einmal abgeworfen?

Auch in den anderen Beispielen ist es immer außerordentlich schwierig, die freien Parameter zu bestimmen.

2.4 Aufgabenteilung

Beobachtet man einen Wespenstamm, so stellt sich heraus, dass es verschiedene funktionale Grup- pen gibt. Untersuchungen haben aber gezeigt, dass alle Wespen genetisch identisch sind. Die Frage ist, wie sich die Wespen derart organisieren, dass sich die Gruppen bilden und auch in entspre- chender St¨arke vorhanden sind; und dies ohne zentrale Planung.

Sehr abgewandelt l¨asst sich dieses Beispiel nutzen, um sich selbst-organisierendes Management durch Agentensysteme zu realisieren.

2.4.2 Regeln

Bevor wir zu den Regeln kommen, muss noch kurz die Umwelt erl¨autert werden. Diese ist diesmal nicht leer, sondern besteht an einem bestimmten Punkt aus der Brut. Diese stimuliert eine Nah- rungsnachfrage. Wird diese befriedigt, dann sinkt sie, andernfalls steigt sie mit der Zeit immer weiter an. Die Wespen folgen drei Regeln:

1. Wenn auf eine andere Wespe getroffen wird, dann k¨ampfe:

• St¨arkere Wespe gewinnt mir gr¨oßerer Wahrscheinlichkeit

• Gewinner erh¨alt etwas Kraft vom Verlierer

2. Wespen in der N¨ahe von Brut tendieren dazu, Futter zu holen

(10)

2.4.3 Formalisierung

Das System kann folgendermaßen formalisiert werden:

h{agenti}, env,{agent:tb, env:tb}i (4) Dabei ist ein Element der Menge der Agenten definiert durch:

h(pi, Fi, σi, ξi, φi),(pi, Fi, σi),(pi, Fi, σi),{timestep(τ)}i (5) Die Variablen haben folgende Bedeutung:

• pPosition des Agenten

• F Kraft des Agenten

• σGrenzwert bis Agent Futter holt

• ξ Lernfaktor: Wie wahrscheinlich ist, dass Agent Futter holt, wenn er schon Futter holen war

• φFaktor zum vergessen, dass der Agent Futter holen war

Schon da die Agenten kämpfen müssen, ist es klar, dass die Position und die Kraft als Input- /Output-Werte vorhanden sein müssen. Die beiden Faktoren zum Lernen und Vergessen hingegen werden nur von der Wespe selbst verändert.

Und die diesmal nicht passive Umwelt ist gegeben durch:

h(p^(D), D, W),{timestep(τ)}i (6)

Die Brut wird mit eniem D bezeichnet f¨urDemand, daher ist p^(D) die Position der Brut, D die Nachfrage selbst undW die von den Agenten verrichtete Arbeit.

2.4.4 Berechnung

Die Differenzierung der Agenten in verschiedene Gruppen wird auch sichtbar, wenn die Brut und ihre Nachfrage nicht implementiert wird, daher wurde dies entsprechend so realisiert. Daher muss lediglich die Realisierung des Kampfes besprochen werden. Dies geschieht mittels der Fermi- Funktion (s. Abbildung 7). Durch diese kann durch einen freien Parameterh bestimmt werden, inwieweit der Ausgang des Kampfes durch die Kraftdifferenz der Agenten determiniert ist.

p(Fi, Fj) = 1

1 +e^h(Fⁱ^−F^j⁾ (7)

7 berechnet die Wahrscheinlichkeit, dass Agentjden Kampf gegen Agentigewinnt. Abbildung 8 zeigt die Kurvenverl¨aufe f¨ur verschiedenesh.

Je gr¨oßerhist, umso mehr f¨allt die KraftdifferenzFi−Fj ins Gewicht. Isthganz klein, dann ist die Fermi Funktion eine waagerecht, isthjedoch sehr groß, dann entsteht eine sigmoide bzw.

Stufenfunktion.

2.4.5 Simulation

Die Aufteilung der Kraft, die am Anfang zuf¨allig verteilt ist, ist in Abbildung 9 sichtbar:

Schon hier wird deutlich, dass nach einer Vielzahl von Zeitschritten genau ein Agent mit Abstand die gr¨oßte Kraft besitzt. Daneben gibt es es kleinere Gruppe von m¨aßig starken Agenten und der Großteil der Agenten hat keine Kraft. Untermauert wird dies durch Abbildung 10:

Die Gruppen wurden gebildet durch die Menge der Kraft eines Agenten im Verhältnis zu der Kraft des stärksten Agenten. Genau ein Agent (die Königin) hat mehr als 90% der maximalen Kraft, mittlere Kraft besitzen die Agenten, die zwischen 10% und 90% der maximalen Kraft besitzen und die schwache Gruppe beinhaltet die restlichen Agenten.

Es wird also deutlich, dass sich drei Gruppen bilden:

(11)

−2 −1.5 −1 −0.5 0 0.5 1 1.5 2 0

0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

Fi−F j p(Fi,Fj)

h=1 h=2 h=0.5

Abbildung 8: Fermi Funktion

0 50 100 150 200 250 300 350 400 450 500

0 5 10 15 20 25 30 35

forces of wasps

timesteps

force

Abbildung 9: Wespen - Kraftverteilung

• Die K¨onigin, die die Kraft der anderen Agenten skaliert.⁴

• Eine mobile, starke Gruppe zum Abwehren der Feinde und zum Auskundschaften der Um- gebung

• Eine Pflegegruppe, die nicht mobil ist und die Brut pflegt.

2.4.6 Umsetzung

Die Umsetzung erfolgte hierbei nur über eine Hauptschleife, die über die Zeitschritte iteriert. Vor Beginn der Schleife wird vorab für jeden Zeitschritt durch Zufall die Anzahl der kämpfenden Wespen ermittelt⁵. In jedem Zeitschritt wird dann ein Begegnungsvektor zufällig ermittelt mit

4Dies ist dadurch m¨oglich, dass der Kampfausgang stochastisch und nicht determiniert ist

5Auch die Anzahl der Wespen, die in die N¨ahe der Brut gelangen wird ermittelt, allerdings wird dies nicht weiter

(12)

0 50 100 150 200 250 300 350 400 450 500 0

5 10 15 20 25 30 35 40 45

groups of wasps

timesteps

number of wasps

low force medium force high force

Abbildung 10: Wespen - Gruppenverteilung

Länge der Anzahl der kämpfenden Wespen. Da aber keine Wespen gegen sich selbst kämpfen sollen, und es auch Probleme bei der abschließenden Kraftzuordnung ergibt, taucht keine Wespe in diesem Vektor (egal in welcher Spalte) doppelt auf (non redundant()). Anschließend wird über die Fermi- Funktion die Gewinner aller Kämpfe ermittelt (fight()) und anschließend mit Vektoroperationen die Kräfte nach obiger Definition verschoben. Dabei kann unterschieden werden zwischen festen und relativen Kaftportionen, allerdings ist nur erstere Wahl sinnvoll, da ansonsten ein erfolgreicher Kampf mit der Königin, auf Grund der stochastischen Natur des Kampfes, verheerende Folgen hätte.

Literatur

[Bonabeau99] Bonabeau, Dorigo, Theraulaz: Swarm Intelligence: From Natural to Artificial Sy- stems.Oxford Press, 1999.

[Kennedy01] Kennedy, Eberhart:Swarm Intelligence.Morgan Kaufmann, 2001.

[Parunak03] Parunak:Making Swarming Happen.Conference on Swarming and C4ISR, 2003.

[Parunak97] Parunak:“Go to the Ant“: Engineering Principles from Natural Multi-Agent Systems.

Annals of Operations Research 75 (1997) 69 101.

[Resnick94] Resnick:Turtles, Termites, and Traffic Jams.MIT Press, 1994.

3 Appendix

3.1 matlab code

3.1.1 flock ex.m function flock_ex

n = 10; %number of fishes T = 50; %number of timesteps L=50; %limits for plot

(13)

vmax = 3;

x = zeros(1,n); %x coordinates y = (-n/2:1:n/2-1)*5; %y coordinates

vx = round(rand(1,n)*vmax); %velocity x coordinate vy = round(rand(1,n)*vmax); %velocity y coordinate

%central of coordination system cx = 0;

cy = 0;

figure(1);

plot(x,y,’bo’);

title(’flock’);

xlabel(’x’);

ylabel(’y’);

legend(’fish’);

axis([-L+cx L+cx -L+cy L+cy]);

M(1)=getframe;

pause for t=1:T

for i=1:n

[x(i) y(i) vx(i) vy(i)] = timestep(i,x,y,vx,vy);

plot(x,y,’bo’);

title(’flock’);

xlabel(’x’);

ylabel(’y’);

legend(’fish’);

axis([-L+cx L+cx -L+cy L+cy]);

M(t*n+i) = getframe;

end %for i

%fit coordinate system [xc yc] = get_center(x,y);

if abs(cx-xc)>L/2, cx = cx + L/2;

end %if

if abs(cy-yc)>L/2, cy = cy + L/2;

end %if end %for t

%********************************************

function [xn,yn,vxn,vyn] = timestep(i,x,y,vx,vy)

%returns new position and velocity for fish i v_distant = 5; %double of minimal distant v_learn = 0.5; %learn rate for velocity v_max = 5;

%learn velocity

I=get_neighbors(i,v_distant*2,x,y);

if isempty(I), vxn = vx(i);

(14)

else,

[vxn vyn] = average_speed(I,vx,vy);

vxn = v_learn*vxn + (1-v_learn)*vx(i);

vyn = v_learn*vyn + (1-v_learn)*vy(i);

end %if

[xd yd] = get_center_orientation(i,x,y); %get correct orientation

%swim to swarm center

if ((xd>v_distant) & (vxn~=0) & (sign(vxn)~=sign(xd))), vxn = vxn*-1;

end %if

if ((yd>v_distant) & (vyn~=0) & (sign(vyn)~=sign(yd))), vyn = vyn*-1;

end %if

if (xd>v_distant),

vxn = vxn+xd*v_learn;

end %if

if (yd>v_distant),

vyn = vyn+yd*v_learn;

end %if

%limit for speed if (abs(vxn)>v_max),

vxn = sign(vxn)*v_max;

end %if

if (abs(vyn)>v_max), vyn = sign(vyn)*v_max;

end %if

%actualize coordinates

x(i) = x(i)+vxn*(3/4+rand(1)/2);

y(i) = y(i)+vyn*(3/4+rand(1)/2);

%check for collisions and abuse them

bcollision = ~isempty(get_neighbors(i,v_distant/2,x,y));

z=10;

while ((bcollision) & (z>0)), x(i) = x(i)-vxn/10;

y(i) = y(i)-vyn/10;

z=z-1;

bcollision = ~isempty(get_neighbors(i,v_distant/2,x,y));

end %while

%save correct coordinates xn = x(i);

yn = y(i);

vxn = vxn/10*z;

vyn = vyn/10*z;

%********************************************

function [xo,yo] = get_center_orientation(i,x,y) [xc yc] = get_center(x,y);

xo = xc-x(i);

yo = yc-y(i);

(15)

%********************************************

function [xc,yc] = get_center(x,y)

%returns center of fishes xc = sum(x)/size(x,2);

yc = sum(y)/size(y,2);

%********************************************

function [sx,sy]=average_speed(I,vx,vy)

%returns average speed of I sx=sum(vx(I))/size(I,2);

sy=sum(vy(I))/size(I,2);

%********************************************

function I=get_neighbors(i,d,x,y)

%get neighbor fishes of i up to distance d z = 1;

I = []; %index set for indices of neighbor fishes for j=1:size(x,2)

if ((i~=j) & (distance(i,j,x,y)<=d)), I(z) = j;

z = z+1;

end %if end %j

%********************************************

function d=distance(i,j,x,y)

%returns distant from i to j

d = ((x(i)-x(j))^2 + (y(i)-y(j))^2)^0.5;

3.1.2 wolf ex.m

function j=wolf_ex(plot_it)

x = [3 0 1 0 1 0 1]; %x coordinates;moose is first!

y = [0 1 2 3 4 5 6]; %y coordinates

f = [0 1 1 1 1 1 1]; %flags: 0 if moose, 1 else L = 25;

m = size(x,2); %number of animals n = 100; %maximum of timesteps if plot_it,

figure(1);

plot(x(1),y(1),’ro’);

hold on;

plot(x(2:m),y(2:m),’bo’);

title(’wolves catch moose’);

xlabel(’x’);

ylabel(’y’);

legend(’moose’,’wolf’);

(16)

axis([-L L -L L]);

hold off;

M(1)=getframe;

pause end %if for j=1:n

for i=1:m

[x(i) y(i)] = get_next_pos(i,x,y,f);

if plot_it,

plot(x(1),y(1),’ro’);

hold on;

plot(x(2:m),y(2:m),’bo’);

title(’wolves catch moose’);

xlabel(’x’);

ylabel(’y’);

legend(’moose’,’wolf’);

axis([-L L -L L]);

hold off;

M(j*n+i) = getframe;

end %if end %for i

if moose_caught(x,y), break;

end %if end %for j

%**************************************************

%get next field position

function [xmax,ymax] = get_next_pos(i,x,y,f) mod_xi = mod(x(i),2);

smax = -100000;

d=(f(i)+1)*2; %velocity for moose=1,wolves=2

%iterate over neighbor cells for xj=x(i)-d:x(i)+d

if mod(xj,2)==mod_xi,

s = get_score(xj,y(i),i,x,y,f);

if choose_rnd(s,smax), smax = s;

xmax = xj;

ymax = y(i);

end %if

if (abs(xj-x(i))<=2) & (d==4),

s = get_score(xj,y(i)+2,i,x,y,f);

xmax = xj;

ymax = y(i)+2;

end %if

s = get_score(xj,y(i)-2,i,x,y,f);

(17)

xmax = xj;

ymax = y(i)-2;

end %if end %if else

s = get_score(xj,y(i)-1,i,x,y,f);

xmax = xj;

ymax = y(i)-1;

end %if

s = get_score(xj,y(i)+1,i,x,y,f);

xmax = xj;

ymax = y(i)+1;

end %if end %if end %for xj

%**************************************************

%get score

function s=get_score(xi,yi,i,x,y,f)

%get nearest animl with flag 1 global k;

k=0.1;

s=0;

%check if position is available for j=1:size(x,2)

if (j~=i) & (xi==x(j)) & (yi==y(j)), s=-10000;

end %if end %for j if s==0,

%calculate distance dmin = 100000;

for j=1:size(x,2)

if (j~=i) & (f(j)==1),

d = dist(xi,yi,x(j),y(j));

if d<dmin, dmin = d;

end %if end %if end %for j

%for moose if f(i)==0,

if (xi==x(i)) & (yi==y(i)), s = -10000;

else

(18)

end %if else %wolves

s = -dist(xi,yi,x(1),y(1))+k*dmin;

end %if end %if

%distance function

function d=dist(x1,y1,x2,y2) dx = abs(x1-x2);

dy = abs(y1-y2);

d = dy + max(dx-dy,0)/2;

%if scores are equal take randomly one of the scores function b = choose_rnd(s,smax)

b = (s>smax) | ((s==smax) & (rand(1)>0.5));

%check if moose is caught function b = moose_caught(x,y) b=1;

for i=2:size(x,2)

b = b & (dist(x(i),y(i),x(1),y(1))==1);

end %for i

3.1.3 wasp ex2.m function wasp_ex2(n,tn)

%n number of wasps

%tn number of timesteps c_limit = n/2;

f_init = 10;

p = rand(2,n)*f_init; %wasp paremeter force and foragers D = zeros(1,tn); %forage demand

y1 = zeros(1,tn); %low force group y2 = zeros(1,tn); %medium force group y3 = zeros(1,tn); %high force group learn = 0.01; %learning coefficient forget = 0.01; %forgetting coefficient

force_transfer = 0.5; %factor for force transfer

v_n = round(rand(tn,2)*c_limit); %meetings and to brood

%going through the time for t=1:tn

v_meet = round(rand(v_n(t,1),2)*(n-1)+1); %which wasps will meet v_meet = non_redundant(v_meet);

v_n(t,1) = size(v_meet,1);

v_brood = round(rand(v_n(t,2),1)*(n-1)+1); %which wasps will be near the brood

%lets fight if v_n(t,1)>0,

winner_looser = fight(v_meet)’-rand(1,v_n(t,1))<=0;

(19)

I_win = find(winner_looser==1);

I_los = find(winner_looser==0);

%transfer force

p(1,v_meet(I_win,1)) = p(1,v_meet(I_win,1)) + min(p(1,v_meet(I_win,2)),force_transfer);

p(1,v_meet(I_win,2)) = max(p(1,v_meet(I_win,2))-force_transfer,0);

p(1,v_meet(I_los,2)) = p(1,v_meet(I_los,2)) + min(p(1,v_meet(I_los,1)),force_transfer);

p(1,v_meet(I_los,1)) = max(p(1,v_meet(I_los,1))-force_transfer,0);

end %if

%grouping

y1(t) = sum(p(1,:)<=1/10*max(p(1,:)));

y2(t) = sum(p(1,:)<=9/10*max(p(1,:)))-y1(t);

y3(t) = n-y1(t)-y2(t);

F(t,:) = p(1,:);

end %for i

%plot the stuff figure(1);

hold on;

plot(1:tn,y1,’b’);

plot(1:tn,y2,’r’);

plot(1:tn,y3,’g’);

legend(’low force’,’medium force’,’high force’);

title(’groups of wasps’) xlabel(’timesteps’) ylabel(’number of wasps’) hold off;

figure(2) plot(F);

title(’forces of wasps’);

xlabel(’timesteps’);

ylabel(’force’);

function v = non_redundant(v_in) k=1;

s=1;

r=[0];

v=[];

if ~isempty(v_in), for i=1:size(v_in,1)

b = 0;

for j=1:size(v_in,2)

b = (sum(find(r==v_in(i,j)))>0) | b;

if ~b,

r(k) = v_in(i,j);

k=k+1;

end %if end %for j if ~b,

v(s,:) = v_in(i,:);

s=s+1;

end %if end %for i else,

(20)

end %if

function v_r=fight(v) v_r = fermi(v(:,1),v(:,2));

%fermi function

function p=fermi(f1,f2) h=1.5;

p = 1./(1+exp(h.*(f1-f2)));