FĂŒhren Sie Ameise. Lauf

Dieser Artikel beschreibt den Prozess der Erstellung eines Simulationsmodells des Verhaltens einer Ameisenkolonie (kann auf Wikipedia gelesen werden ) in der Simulationsumgebung "AnyLogic". Dieser Artikel ist praktisch. Es wird die Verwendung des Ameisenalgorithmus zur Lösung des Problems des Handlungsreisenden in Betracht gezogen (Sie können hier lesen ).



Kurz ĂŒber die Essenz


Das Wesentliche des Problems des reisenden VerkĂ€ufers ist, dass der reisende VerkĂ€ufer (VerkĂ€ufer) N StĂ€dte besuchen muss, nachdem er jede von ihnen nur einmal auf dem kĂŒrzesten Weg besucht hat. Da diese Aufgabe NP-kompliziert ist und die Anzahl der Optionen fĂŒr alle möglichen Routen zwischen N StĂ€dten als „N!“ Berechnet wird, erhöht sich die kĂŒrzeste Routensuchzeit exponentiell mit einer Zunahme von N. Dementsprechend wird die kĂŒrzeste Routensuchzeit (Lösungssuchzeit) unter Verwendung des Algorithmus Die „erschöpfende Suche“ (die eine genaue Lösung ergibt) mit der Anzahl der StĂ€dte N> 16 nimmt stark zu (ist exponentiell). Daher werden wir nicht nach der kĂŒrzesten Route in der LĂ€nge suchen, sondern mit dem „Ameisenalgorithmus“ in endlicher Zeit nahe (rational) daran sein.

Ein paar Worte zu AnyLogic sind ein leistungsstarkes Tool, mit dem Sie Simulationsmodelle unterschiedlicher KomplexitĂ€t erstellen können. Es implementiert verschiedene AnsĂ€tze der Simulation. Wir werden nur einen der AnsĂ€tze analysieren, nĂ€mlich die "Agent" -Modellierung. Es ist in der Programmiersprache Java implementiert, die die vorhandenen Tools ergĂ€nzt. Der Hauptnachteil von "AnyLogic" ist die BeschrĂ€nkung der kostenlosen Version auf die Anzahl der erstellten Agenten, deren Anzahl 50.000 nicht ĂŒberschreiten darf. "Agent" ist die Grundeinheit des AnyLogic-Simulationssystems. Weitere Informationen finden Sie auf der Website www.anylogic.ru

Werkzeuge


1. Anylogic - Laden Sie die kostenlose Version von hier herunter. Www.anylogic.ru/downloads
AnyLogic- Erstbekanntschaft : Die

AnyLogic-OberflÀche ist in Abbildung 1 dargestellt. Sie enthÀlt:
  • Der grĂŒne Bereich ist der Raum des Agenten, in dem wir erstellen werden.
  • roter Bereich - Eigenschaften des fokussierten Objekts;
  • Palette - Werkzeuge, die Sie beim Erstellen eines Modells verwenden können;
  • Projekte - die Struktur des entwickelten Modells.



Feige. 1- AnyLogic-Popup-Fenster

Projekterstellung


Hier ist alles einfach. Klicken Sie auf den MenĂŒpunkt „Datei“ neben „Erstellen“ und dann auf „Modell“, geben Sie den Modellnamen ein und klicken Sie auf die SchaltflĂ€che „Fertig stellen“ (Abb. 2).


Feige. 2- Erstellen eines Modells

StÀdte erstellen


Nun, fangen wir an. Als erstes erstellen wir die sogenannten StĂ€dte (oben in der Grafik), die die Ameise besuchen wird. Warum öffnen wir die Registerkarte „Agent“ in der Palette und ziehen den roten Kreis mit dem kleinen Mann von dort in den „Hauptagenten“, wie in Abbildung 3 dargestellt


. 3- StÀdte

erstellen Nachdem Sie die Maustaste losgelassen haben, wird ein Dialogfeld angezeigt ("Schritt 1"), in dem Sie aufgefordert werden, einen Agenten zu erstellen. Wo Sie das Element "Agentenpopulation" auswĂ€hlen und auf die SchaltflĂ€che "Weiter" klicken mĂŒssen.


Feige. 4- StÀdte erstellen

Das folgende Dialogfeld wird angezeigt (Schritt 2), in dem Sie den Namen des neuen Agententyps und den Namen der Agentenpopulation eingeben mĂŒssen. Geben Sie den Typ "MyTown" und den Namen der Bevölkerung "myTowns" ein und klicken Sie auf die SchaltflĂ€che "Weiter".


Feige. 4a - Geben Sie den Namen des neuen Agenten ein

Dann erscheint das folgende Fenster (Schritt 4.). Hier wĂ€hlen wir „2D Agent Animation“ und das Symbol mit der Aufschrift „Plant“ und klicken auf die SchaltflĂ€che „Finish“ (Abb. 5).


Feige. 5- Animation fĂŒr den Agenten

hinzufĂŒgen Erstellen Sie nun eine Variable, die die anfĂ€ngliche Anzahl der StĂ€dte in unserem Modell bestimmt. Ziehen Sie aus der "Palette" das Symbol mit der Aufschrift "Variable" in den Agenten "Main" und geben Sie dessen Namen "numberTown" ein. Klicken Sie anschließend auf das Symbol unserer Variablen und geben Sie auf der Registerkarte Eigenschaften den Anfangswert ein, der beispielsweise 10 entspricht, und wĂ€hlen Sie den Typ „int“ aus (Abb. 6).


Feige. 6- Erstellen einer Variablen

Jetzt legen wir den Anfangswert unserer Stadtbevölkerung auf „myTowns“ fest, fĂŒr den wir auf das entsprechende Symbol klicken und auf der Registerkarte „Eigenschaften“ im Feld „Anfangsanzahl der Agenten“ den Namen der zuvor erstellten Variablen schreiben (Abb. 7).


Feige. 7 - Ändern der Eigenschaften der "myTowns" -Population Als nĂ€chstes werden

wir die Schlussfolgerung unserer StĂ€dte im "Main" -Agenten an einer zufĂ€lligen Stelle ziehen. Der Speicherplatz ist auf ein Quadrat von 400 x 400 Pixel begrenzt. WĂ€hlen Sie auf der Registerkarte "Projekte" mit der Maus den Agenten "Haupt" aus und fĂŒgen Sie auf der Registerkarte "Eigenschaften" im Feld "Beim Start" den folgenden Java-Code hinzu (Abb. 7a):
for (int i=0; i<myTowns.size(); i++) {
	myTowns.get(i).setXY(uniform(0,400), uniform(0,400));
}

Wo:
  • myTowns.size () - die Anzahl der erstellten StĂ€dte;
  • myTowns.get (i) .setXY (Uniform (0,400), Uniform (0,400)) - Legen Sie die X- und Y-Koordinaten fĂŒr die i-te Stadt fest.
  • uniform (0,400) - eine Funktion, die eine Zufallszahl im Bereich von 0 bis 400 gemĂ€ĂŸ dem ebenso wahrscheinlichen Verteilungsgesetz einer Zufallsvariablen zurĂŒckgibt. Die AnyLogic-Umgebung verfĂŒgt ĂŒber ein umfangreiches Toolkit fĂŒr die Arbeit mit verschiedenen Verteilungen von Zufallsvariablen. Es gibt einen eingebauten Konstruktor fĂŒr Wahrscheinlichkeitsverteilungen, der in der Symbolleiste verfĂŒgbar ist.

Wo:
  • myTowns.size () - die Anzahl der erstellten StĂ€dte;
  • myTowns.get (i) .setXY (Uniform (0,400), Uniform (0,400)) - Legen Sie die X- und Y-Koordinaten fĂŒr die i-te Stadt fest.
  • uniform(0,400) – , 0 400 . AnyLogic . .



Feige. 7a - Wir arrangieren die StÀdte.

Dann können wir bereits sehen, was wir getan haben und unser Modell starten. Verwenden Sie dazu die Taste "F5", klicken Sie darauf und das Fenster zum Starten des Experiments wird geöffnet (siehe Abbildung 8)


. 8 - Experiment starten

Klicken Sie anschließend auf die SchaltflĂ€che "AusfĂŒhren" in der unteren linken Ecke des Fensters und das Experiment beginnt. Sie sollten ein Fenster mit dem Inhalt auf dem Bildschirm erhalten, wie in Abbildung 9 gezeigt


. 9 - Das Ergebnis des Experiments In

diesem Schritt haben wir 10 StÀdte erstellt und sie an einer zufÀlligen (stochastischen) Stelle auf unserem Bildschirm platziert. Kommen wir nun zur Erschaffung unserer "Ameisen".

Erstelle eine Ameise


Die Hauptkampfeinheit unseres Modells wird also eine Ameise sein. Wir mĂŒssen es zuerst erstellen und dann sein Verhalten modellieren.

Das Erstellen einer Ameise Ă€hnelt dem Erstellen einer Stadt. WĂ€hlen Sie in der "Palette" "Agent" und ziehen Sie es auf "Main". WĂ€hlen Sie "Population of Agents", dann "Ich möchte einen neuen Agententyp erstellen", geben Sie "Name des neuen Typs" und "Population Name" "MyAnt" "myAnts" ein und klicken Sie auf "Next". Danach wĂ€hlen wir die Animation „2D“ und zum Beispiel das Symbol mit der Aufschrift „Fighter“. DrĂŒcken Sie „Finish“. Es sollte sich wie in Abbildung 10 gezeigt herausstellen


. 10 - Ameisen erstellen

Stimmen Sie zu, das Flugzeug sieht nicht wie eine Ameise aus, also werden wir es reparieren. Wir gehen in die Suchmaschine und suchen nach einem Bild, das eine Ameise zeigt, und Ă€ndern das Flugzeug in eine Ameise. Warum doppelklicken wir auf den roten Kreis neben "myAnts"? Danach öffnet sich die Registerkarte „myAnt“, an der Sie das Flugzeug entfernen und die Ameise an ihrer Stelle platzieren mĂŒssen (Abb. 11).


Feige. 11 - Registerkarte MyAnt

WĂ€hlen Sie die Ebene mit der Maus aus und drĂŒcken Sie "Entf". Gehen Sie als NĂ€chstes zur Registerkarte "PrĂ€sentation" und ziehen Sie das Element "Bild" von dort. Danach wird automatisch ein Dialogfeld zur Auswahl einer Datei geöffnet. WĂ€hlen Sie die Datei mit unserer Ameise aus (Abb. 12) und klicken Sie auf OK.


Feige. 12 - MyAnt Tab mit Ameise und bereits ohne Flugzeug

Mach weiter. Skalieren Sie die Ameise und bewegen Sie sie an die Stelle, an der sich das Flugzeug befand. Es sollte sich wie in Abbildung 12a gezeigt herausstellen. Alle diese VorgĂ€nge werden mit der Maus ausgefĂŒhrt.


Feige. 12a - Registerkarte MyAnt mit Ameise

Wir beleben die Ameise wieder


Jetzt mĂŒssen wir unserer frisch gebackenen Ameise beibringen, zwischen StĂ€dten zu kriechen. Richtig, bisher ohne BerĂŒcksichtigung des mathematischen Modells, aber trotzdem laufen lassen. Öffnen Sie daher das Diagramm „Zustandsdiagramm“ in der „Palette“ und fahren Sie fort. Wir ĂŒbertragen die folgenden Blöcke und verbinden sie miteinander:
  • Der Beginn des Zustandsdiagramms ist der Ausgangspunkt des Lebenszyklus unserer Ameise.
  • Zustand - Dieser Block charakterisiert den Zustand des Lebenszyklus unserer Ameise. Solche Blöcke werden in StĂŒcken benötigt.
  • Übergang - ein Pfeil, der unsere „Staaten“ miteinander verbindet und unter bestimmten Bedingungen den Übergang von einem „Staat“ zu einem anderen „Staat“ durchfĂŒhrt.

Infolgedessen sollte sich herausstellen, wie in Abbildung 13 dargestellt


. 13 - Die Logik des Verhaltens der Ameise

Schreiben wir nun die anfĂ€ngliche Logik des Ameisendiagramms. Wir wĂ€hlen mit der Maus den Pfeil aus, der den Block unter dem Namen „Stadt auswĂ€hlen“ verlĂ€sst, und fĂŒgen den folgenden Code im Feld „Aktion“ auf der Registerkarte „Eigenschaften“ hinzu (Abb. 14):
for (int i=0; i<main.myTowns.size(); i++) {
	if (randomTrue(0.5)) {
		this.moveTo(main.myTowns.get(i));
		break;
	} 
}

Hier ist alles sehr einfach, wir durchlaufen den Zyklus in allen StĂ€dten und werfen eine MĂŒnze (wir erzeugen eine Zufallsvariable mit einer Wahrscheinlichkeit von 0,5). Wenn ihr Wert wahr ist (Adler), schicken wir die Ameise in diese Stadt und verlassen den Zyklus. Der Ausdruck "this.moveTo (main.myTowns.get (i))" ist eine Funktion, die einen Agenten an einen anderen sendet.


Feige. 14 - Legen Sie die anfĂ€ngliche Logik fĂŒr die Bewegung der Ameise fest.

Klicken Sie anschließend auf den Pfeil, der den Block "Bewegung" verlĂ€sst, und legen Sie auf der Registerkarte "Eigenschaften" im Feld "Tritt" den Wert "Beim Empfang einer Nachricht" fest und wĂ€hlen Sie im Feld "Tritt" die Option "Beim Empfang der angegebenen Nachricht" aus. »Wie in Abbildung 15 gezeigt


. 15 - Stellen Sie die Logik fĂŒr den Übergang zwischen "Bewegung" und "Alles umgehen" ein.

Konfigurieren Sie nun den letzten Pfeil, der aus dem Block "Bewegung" kommt. Wir wĂ€hlen es mit der Maus aus und setzen auf der Registerkarte "Eigenschaften" im Übergangsfeld "Bei Ankunft des Agenten". Die endgĂŒltige Ansicht des „Zustandsdiagramms“ sollte wie in Abbildung 16 dargestellt sein


. 16 - Zustandsdiagramm mit konfigurierten ÜbergĂ€ngen zwischen Blöcken

Schauen wir uns also an, wie das "Zustandsdiagramm" des Ameisenverhaltens funktioniert:
  1. Der erste Zustand, in den die Ameise fÀllt, ist "Vybor_city", bisher wurde keine Aktion formuliert.
  2. Dann geht er beim Übergang in den nĂ€chsten Zustand ĂŒber. In diesem Übergang haben wir einen Code hinzugefĂŒgt, der einen Zyklus durch alle Berge startet und Ameisen durch die StĂ€dte laufen lĂ€sst.
  3. Im Block "Bewegung" befindet sich die Ameise, bis sie in der zuvor ausgewÀhlten Stadt ankommt.
  4. Außerdem hat er zwei Möglichkeiten. Zuerst kehrt er zum Block "City_Choice" zurĂŒck und alles wird noch einmal wiederholt. Auf dem zweiten Weg muss er gehen, wenn er bereits alle StĂ€dte besucht hat. Bisher ist der zweite Weg bei uns nicht eingerichtet. Wir werden uns etwas spĂ€ter darum kĂŒmmern.



Feige. 17 - Bedienung des Zustandsdiagramms

Jetzt können wir "F5" drĂŒcken, um zu sehen, was passiert ist (Abb. 18).


Feige. 18 - Die Wiederbelebung der Ameisen

Definieren Sie die Kriterien


Also, was sind diese Kriterien (Regeln):
  1. Eine Ameise sollte jede Stadt nur einmal besuchen.
  2. Ameise, als er alle StÀdte besuchte, beendet seine Bewegung in der letzten Stadt.

Diese Kriterien werden uns durch den Zustand des Problems des reisenden VerkÀufers vorgegeben. Jede Ameise wird bei uns eine Art reisender VerkÀufer sein, der durch StÀdte reist.

Lassen Sie uns die Ameise lehren, diese Regeln einzuhalten. Übertragen Sie auf der Registerkarte "Palette", "Agent", "Collection" und "Variable" auf die Registerkarte "MyAnt" und benennen Sie sie zuerst als "isVisited" und dann als "distance". Die erste berĂŒcksichtigt die StĂ€dte, die wir bereits besucht haben, und die zweite die Entfernung, die die Ameise zurĂŒckgelegt hat.


Feige. 19 - Variablen

hinzufĂŒgen Richten Sie die isVisited-Auflistung ein. Warum wĂ€hlen wir es mit der Maus aus und setzen den "Typ" der "int" -Elemente auf der Registerkarte "Eigenschaften", wie in Abbildung 20 gezeigt.
FĂŒr die Variable "Abstand" in ihren Eigenschaften setzen Sie im Feld "Anfangswert" "0" und den Variablentyp "double". ".


Feige. 20 - Sammlung vom Typ "int"

WÀhlen Sie nun den Pfeil aus, der den Block "City_block" verlÀsst, und Àndern Sie den Code im Feld "Aktion" in den folgenden:
for (int i=0; i<main.myTowns.size(); i++) {
	if (randomTrue(0.9) && isVisited.indexOf(i)==-1) {
		this.moveTo(main.myTowns.get(i));
		distance=distance+this.distanceTo(main.myTowns.get(i));
		isVisited.add(i);
		break;
	} 
}

Im obigen Code haben wir einen Scheck fĂŒr die StĂ€dte hinzugefĂŒgt, in denen wir bereits einen Besuch geschafft haben, und dabei die StĂ€dte berĂŒcksichtigt, die wir besucht haben, sowie die zurĂŒckgelegte Entfernung berĂŒcksichtigt. Der Code ist recht einfach, ich denke, es wird nicht schwer fĂŒr Sie zu verstehen sein.

Sie können versuchen, unser Modell „F5“ zu starten und zu sehen, was passiert ist. Jetzt passieren die Ameisen alle StĂ€dte nur noch einmal und vollenden ihre Bewegung im Block.

Ändern Sie die anfĂ€ngliche Platzierung der Ameisen


In diesem Schritt bestimmen wir fĂŒr jede Ameise zufĂ€llig eine Stadt, von der aus sie ihre Reise beginnen wird. WĂ€hlen Sie auf der Registerkarte "Projekte" mit der Maus den Agenten "Haupt" aus und fĂŒgen Sie dann auf der Registerkarte "Eigenschaften" den folgenden Code in das Feld "Beim Start" ein (Abb. 20a):
for (int i=0; i<myAnts.size(); i++) {
	//        
	int startTown = uniform_discr(0,myTowns-1);
	//     
	myAnts.get(i).setPosition(myTowns.get(startTown));
	//      
	myAnts.get(i).isVisited.add(startTown);
}



Feige. 20a - Ameisen nach Stadt ordnen

Ich habe eine zufĂ€llige Auswahl der ursprĂŒnglichen Stadt getroffen. Sie können zunĂ€chst alle Ameisen in nur einer Stadt identifizieren.

Ameisen unvorhersehbar machen


Lassen Sie uns die folgende Formel in unser Modell einfĂŒhren:



wobei Pi die Wahrscheinlichkeit des Übergangs entlang des Pfades des i-ten Pfades ist, li die LĂ€nge des i-ten Übergangs ist, fi die Menge an Pheromon am i-ten Übergang ist, q der Wert ist, der die "Gier" des Algorithmus bestimmt, p - der Wert, der die "Herde" des Algorithmus bestimmt, mit q + p = 1.

Ich habe diese Formel von der Website ausgeliehen .

Mit dieser Formel können Sie in einfachen Worten die Wahrscheinlichkeit berechnen, mit der die Ameise den Übergang zu einer bestimmten Stadt vornehmen muss.

Jetzt mĂŒssen wir mehrere Variablen hinzufĂŒgen, ohne die wir nicht auskommen können. Warum zur Registerkarte „Main“ zurĂŒckkehren, Abbildung 21.


Abb. 21 - Tab "Main"

Also fĂŒgen wir die Variable "numberAnt" hinzu, in der wir die GrĂ¶ĂŸe der Ameisenkolonie speichern. Wir setzen seinen Typ auf "int" und der Anfangswert ist 100.


Abb. 21 - Variable "numberAnt" WĂ€hlen Sie als

NĂ€chstes die Grundgesamtheit "myAnts" aus und setzen Sie das Feld "Initial number of agents" auf "numberAnt".

Die Variable "p", die die Herde des Algorithmus bestimmt. Sein Typ ist doppelt und der Anfangswert ist 0,5.

Die Variable "q", die die Gier des Algorithmus bestimmt. Sein Typ ist doppelt und der Anfangswert ist 0,5.


Feige. 22 - Variablen "q und p"

Jetzt setzen wir einen zufĂ€lligen Pheromonwert fĂŒr jede Kante (Straße) zwischen den StĂ€dten. Warum eine Variable (zweidimensionales Array) "matrixF" erstellen? Stellen Sie es auf der Registerkarte "Eigenschaften" im Feld "Typ" ein, wĂ€hlen Sie den Wert "Andere" und schreiben Sie "double [] []" in das Feld den Anfangswert "new double [numberTown] [numberTown]" (Abb. 23).


Feige. 23 - Erstellen eines zweidimensionalen Arrays "matrixF". Pheromonmatrix

Als nĂ€chstes mĂŒssen wir diese Matrix initialisieren. Mit anderen Worten, fĂŒllen Sie es mit zufĂ€lligen Werten. Wir nehmen den Pheromonwert zufĂ€llig im Bereich von 0,1 bis
1. WĂ€hlen Sie dazu auf der Registerkarte „Projekte“ mit der Maus den Agenten „Main“ aus und fĂŒgen Sie auf der Registerkarte „Eigenschaften“ den folgenden Code in das Feld „Beim Start“ ein (Abb. 23a):
for (int i=0; i<myTowns.size(); i++) {
	for (int j=0; j<myTowns.size(); j++) {
		matrixF[i][j]=uniform(0.1,1);
	}
} 



Feige. 23a - Initialisierungscode der Pheromonmatrix

Nun kehren wir zur Registerkarte „MyAnt“ zurĂŒck und berechnen die Übergangswahrscheinlichkeit gemĂ€ĂŸ der obigen Formel. WĂ€hlen Sie den Übergang zwischen "City_Choice" und "Motion" und Ă€ndern Sie den Code im Feld "Aktion" wie folgt (Abb. 24):
//       
double denominator=0; 
//          
for (int i=0; i<main.myTowns.size(); i++) {
	if (isVisited.indexOf(i)==-1) {	//     
	    //  i   
		denominator=denominator+(Math.pow(this.distanceTo(main.myTowns.get(i)), main.q)*Math.pow(main.myTowns.get(i).f, main.p));
	} 
}
//      i 
double Pi=0;
//    
double probility=uniform(0,1);
for (int i=0; i<main.myTowns.size(); i++) {
	//        Pi
	if (isVisited.indexOf(i)==-1) {
		//     i-      
		Pi=Pi+(Math.pow(this.distanceTo(main.myTowns.get(i)), main.q)*Math.pow(main.myTowns.get(i).f, main.p))/denominator;
	}
	//      Pi      probility
	if (probility<Pi && isVisited.indexOf(i)==-1) {
		//       i  
		this.moveTo(main.myTowns.get(i));
		//     
		distance=distance+this.distanceTo(main.myTowns.get(i));
		//           
		isVisited.add(i);
		break;
	} 
}



Feige. 24 - Wir legen das Verhalten der Ameise basierend auf dem analytischen Ausdruck des oben

Gesagten fest . Jetzt erklÀre ich ein wenig, was was ist:
  • li - this.distanceTo (main.myTowns.get (i)), der LĂ€ngenwert zwischen der aktuellen Position der Ameise und der Stadt „i“;
  • fi - main.matrixF [currentPos] [i], der Wert des Pheromonspiegels zwischen der aktuellen Stadt und der Stadt „i“;
  • Nenner - Nenner + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.matrixF [currentPos] [i], main.p)) ;, Nenner Pi
  • Pi - Pi + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.myTowns.get (i) .f, main.p)) / Nenner, die Wahrscheinlichkeit, dass sich die Ameise von der aktuellen Stadt in die Stadt „i“ bewegt.

Als nĂ€chstes wĂ€hlen wir mit der Maus den Übergang zwischen den Blöcken "Bewegung" und "Alle umgangen" aus und wĂ€hlen im Feld "Tritt" die Option "Wenn die Bedingung erfĂŒllt ist" aus. Im Feld "Bedingung" schreiben wir die Bedingung, dass die Ameise "isVisited.size () == main.myTowns.size ()" stoppt. (Abb. 25).


Feige. 25 - Bestimmen Sie die Bedingungen fĂŒr das Stoppen der Ameise.

Dann können Sie das Modell „F5“ ausfĂŒhren und sehen, was passiert ist. Ameisen reisen zwischen StĂ€dten mit einer Wahrscheinlichkeit, die gemĂ€ĂŸ dem obigen analytischen Ausdruck berechnet wird.

Aktualisieren des Pheromonwerts


Lassen Sie uns nun zwei Dinge tun. Die erste Aktion besteht darin, den Pheromonwert am Rand zwischen den StÀdten zu erhöhen, an denen die Ameise vorbeiging. Die zweite ist die Verdampfung von Pheromon an den RÀndern zwischen StÀdten, die darin besteht, den Wert von Pheromonen im VerhÀltnis zur Simulationszeit zu verringern.

Um mit der ersten Aktion zu beginnen, werden wir den Wert des Pheromons der Rippe zwischen der Stadt, in der sich die Ameise befindet und in die sie gehen wird, aktualisieren. Der Wert, um den wir den aktuellen Wert der Pheromonkanten zwischen StĂ€dten erhöhen, wird sehr, sehr einfach berechnet. Wir nehmen unseren maximalen Anfangswert des Pheromonwerts = 1 cu und dividiere es durch die Entfernung zwischen der Stadt, in der sich die Ameise befindet, und der Stadt, in die sie gehen wird. Je kleiner der Abstand zwischen den StĂ€dten ist, desto grĂ¶ĂŸer ist dementsprechend der Wert, um den der Pheromonspiegel der Rippe erhöht wird. Warum wĂ€hlen wir den MyAnt-Agenten auf der Registerkarte Projekte aus, wĂ€hlen mit der Maus den Übergang zwischen den Blöcken "City_title" und "Movement" aus und fĂŒgen dem Aktionsfeld den folgenden Code hinzu: "main.matrixF [currentPos] [i] = main.matrixF [currentPos] [i ] + 1 / this.distanceTo (main.myTowns.get (i); ”.Das Ergebnis sollte wie in Abbildung 26 dargestellt sein


Feige. 26 - Aktualisieren Sie den Wert des Pheromonspiegels der Rippen, den die Ameise weitergegeben hat.

Nun fahren wir mit Schritt 2 fort und erstellen ein Ereignis, das die Verdunstung des Pheromons auf den Rippen zwischen den StĂ€dten simuliert. WĂ€hlen Sie auf der Registerkarte "Projekte" den "Haupt" -Agenten aus und erstellen Sie dort einige weitere Variablen. Die erste ist "IntensitĂ€t" - sie bestimmt die Geschwindigkeit (IntensitĂ€t) der Pheromonverdampfung (Anfangswert "0,5", Typ "doppelt"). Der zweite „Teil“ kennzeichnet den Anteil, um den der Wert des Pheromons an der Kante abnimmt (Anfangswert „0,9“, Typ „double“).


Feige. 27 - Erstellen Sie die Variablen "IntensitÀt" und "Teil"

Als nĂ€chstes nehmen wir das "Ereignis" -Element aus der "Palette" der Registerkarte "Agent" und ĂŒbertragen es auf den "Haupt" -Agenten und nennen es "Verdunstung" - dieses Element simuliert die Verdunstung von Pheromon an den RĂ€ndern. Wir klicken mit der Maus darauf und wĂ€hlen in den "Eigenschaften" im Feld "Ereignistyp" den Wert "Mit einer bestimmten IntensitĂ€t" im Feld "IntensitĂ€t" aus und schreiben den Namen der Variablen, in der der Wert "IntensitĂ€t" gespeichert ist. Die Reaktionszeit betrĂ€gt Sekunden. FĂŒgen Sie als NĂ€chstes den folgenden Code zur Aktion hinzu:
for (int i=0; i<myTowns.size(); i++) {
	for (int j=0; j<myTowns.size(); j++) {
		matrixF[i][j]=matrixF[i][j]*Part;
		if (matrixF[i][j]<0.1) matrixF[i][j]=0.1;
	}
}

Wenn das Ereignis „Verdunstung“ ausgelöst wird, werden die Pheromonspiegel in der MatrixF-Matrix aktualisiert. Daher sollten Sie in der Lage sein, die in Abbildung 28 gezeigten Schritte


auszufĂŒhren. 28 - Erstellen Sie das Ereignis "Verdunstung"

Bestimmen Sie den Gewinner


In diesem Schritt fĂŒgen wir einen Code hinzu, der den Gewinner unseres Ameisenmarathons bestimmt. Der Gewinner ist die Ameise, die den kĂŒrzesten Weg zurĂŒckgelegt hat. ZusĂ€tzlich zu allem zeichnen wir nach dem Ende des Marathons diese Route auf dem Bildschirm. Um dies zu erreichen, erstellen wir im Agenten "Main" drei Variablen "bestAnt", "bestDistance" und "numberFinish". In der Variablen "bestAnt" speichern wir den Index der "schnellsten" Ameise, der Typ der Variablen ist "int" und der Anfangswert wird auf "-1" gesetzt. In der Variablen "bestDistance" speichern wir den aktuellen Wert der besten RoutenlĂ€nge zwischen StĂ€dten, der Typ der Variablen ist "double" und der Anfangswert wird auf unendlich "unendlich" gesetzt. In der Variablen "numberFinish" speichern wir die Anzahl der Ameisen, die unseren Marathon beendet haben.Der Typ der Variablen ist "int" und der Anfangswert ist "0" (Abb. 29).


Feige. 29 - Erstellen eines Variablenereignisses

Als NĂ€chstes erstellen wir eine Funktion, die nach Abschluss aller Ameisen die Linien der besten Route zwischen den StĂ€dten zeichnet. Warum ziehen wir aus der "Palette" ein Element mit der Namensfunktion in den Agenten "Main". Setzen Sie den Funktionsnamen auf drawPath und fĂŒgen Sie auf der Registerkarte Eigenschaften im Feld Funktionskörper den folgenden Code hinzu:
//        
for (int i=0; i<myAnts.get(bestAnt).isVisited.size()-1; i++) {
	//    
	ShapeLine myLine = new ShapeLine();
	//            i
	myLine.setX(myTowns.get(myAnts.get(bestAnt).isVisited.get(i)).getX());
	myLine.setY(myTowns.get(myAnts.get(bestAnt).isVisited.get(i)).getY());
	//            i+1
	myLine.setEndX(myTowns.get(myAnts.get(bestAnt).isVisited.get(i+1)).getX());
	myLine.setEndY(myTowns.get(myAnts.get(bestAnt).isVisited.get(i+1)).getY());
	//    ""
	myLine.setColor(blue);
	//   
	myLine.setLineStyle(LINE_STYLE_SOLID );
	//   
	myLine.setLineWidth(1);
	//    
	presentation.add(myLine);	
}
	//           
	ShapeLine myLine = new ShapeLine();
	myLine.setX(myTowns.get(myAnts.get(bestAnt).isVisited.get(myAnts.get(bestAnt).isVisited.size()-1)).getX());
	myLine.setY(myTowns.get(myAnts.get(bestAnt).isVisited.get(myAnts.get(bestAnt).isVisited.size()-1)).getY());
	myLine.setEndX(myTowns.get(myAnts.get(bestAnt).isVisited.get(0)).getX());
	myLine.setEndY(myTowns.get(myAnts.get(bestAnt).isVisited.get(0)).getY());
	myLine.setColor(blue);
	myLine.setLineStyle(LINE_STYLE_SOLID );
	myLine.setLineWidth(1);
	presentation.add(myLine);

Daher sollten Sie in der Lage sein, die in Abbildung 29a gezeigten Schritte auszufĂŒhren.


Feige. 29a - Erstellen Sie die Funktion "drawPath".

Nun kehren wir zu unseren Ameisen zurĂŒck und fĂŒgen einen Code hinzu, der die Ameise des Gewinners und die LĂ€nge der besten Route bestimmt und diese Route zwischen StĂ€dten zeichnet. WĂ€hlen Sie auf der Registerkarte "Projekte" den Agenten "MyAnt" aus, wĂ€hlen Sie dann den Block "Alle umgangen" aus und fĂŒgen Sie dem Feld "Anmeldeaktion" den folgenden Code hinzu:
//    
main.numberFinish++;
//      
if (main.bestDistance>distance) {
	//           
	//      
	main.bestDistance=distance;
	//    
	main.bestAnt = this.getIndex();
}
//         Main   
if (main.numberFinish==main.myAnts.size()) main.drawPath();

Es sollte sich wie in Abbildung 30 gezeigt herausstellen


. 30 - HinzufĂŒgen von Logik zum Block "Alle umgangen".

Dann können Sie "F5" drĂŒcken und das Modell ausfĂŒhren. Ameisen rennen herum und suchen nach Routen. Wenn die StĂ€dte fertig sind, verbindet sich die blaue Linie. Dies ist die beste Route.

FĂŒgen Sie dem Modell ein Histogramm hinzu


Damit das Modell wissenschaftlicher wird, mĂŒssen Sie ein Diagramm hinzufĂŒgen. Daher werden wir nicht nur ein Diagramm und ein Histogramm hinzufĂŒgen, die uns die Verteilung der LĂ€nge der Routen zeigen, die die Ameisen ĂŒberwunden haben. Warum auf der Registerkarte "Projekte" den Agenten "Main" auswĂ€hlen und zu seinem Bereich gehen. Außerdem gehen wir in der "Palette" zur Registerkarte "Statistik" und ĂŒbertragen von dort zum "Haupt" -Agenten das Element "Histogrammdaten" und direkt das "Histogramm" selbst. Dann wĂ€hlen wir die Histogramme mit der Maus aus und geben auf der Registerkarte "Eigenschaften" im Feld "Daten" den Namen unserer "Histogrammdaten" an, d. H. "Daten".

Es sollte sich wie in Abbildung 31 gezeigt herausstellen


. 31 - Erstellen eines Zeitplans

Danach mĂŒssen wir wieder zu unserer Ameise zurĂŒckkehren und sie das "Histogramm" mit den Werten der LĂ€nge der Route fĂŒllen lassen. WĂ€hlen Sie auf der Registerkarte "Projekte" den Agenten "MyAnt" aus und wechseln Sie in dessen Bereich. WĂ€hlen Sie als NĂ€chstes den Block "Alle umgehen" und fĂŒgen Sie eine Zeile "main.data.add (distance);" hinzu. Es sollte sich wie in Abbildung 32 gezeigt herausstellen


. 32 - Erstellen eines Diagramms

DrĂŒcken Sie anschließend "F5" und untersuchen Sie das Verhalten des Ameisenalgorithmus. Es sollte sich herausstellen, etwas wie in Abbildung 33.


Abb. 33 - Modellierung

Fazit


Und am Ende empfehle ich, dem Modell mehr Unvorhersehbarkeit hinzuzufĂŒgen. WĂ€hlen Sie dazu auf der Registerkarte „Projekte“ mit der Maus das Element „Simulation: Main“ aus und setzen Sie den Parameter „ZufĂ€lligkeit“ auf der Registerkarte „Eigenschaften“ auf „ZufĂ€llige Anfangszahl (eindeutige LĂ€ufe)“. Dadurch wird jeder Modellstart eindeutig (Abb. 34).


Feige. 34 - ZufÀllige LÀufe machen

Vielen Dank fĂŒr Ihre Aufmerksamkeit! Der Quellcode kann von GitHub heruntergeladen werden

All Articles