Künstlicher Bienenstock-Algorithmus (ABHA): Tests und Ergebnisse
116
4
1. Einführung
Im vorangegangenen Artikel haben wir die faszinierende Welt des Künstlichen Bienenstock-Algorithmus (artificial Bee Hive Algorithm, ABHA) erkundet und seine Funktionsprinzipien eingehend untersucht. Wir haben die Struktur und die Klasse beschrieben sowie den Pseudocode des Algorithmus zusammen mit den Methoden Moving und Revision vorgestellt. Diese Einführung bildet die Grundlage für das weitere Studium und Verständnis des Algorithmus.
In diesem Artikel werden wir uns weiter mit der Codierung befassen und alle übrigen Methoden behandeln. Wie immer werden wir Tests mit verschiedenen Testfunktionen durchführen, um die Effizienz und Leistung des Algorithmus zu bewerten. Abschließend fassen wir die Ergebnisse der Arbeit des Algorithmus in der Bewertungstabelle zusammen.
Erinnern wir uns an die wichtigsten Punkte des ABHA-Algorithmus, der auf dem Modell des individuellen Zustands und Verhaltens der Bienen basiert:
- Jede Biene wird als individueller Agent dargestellt, dessen Verhalten durch Zustände (Anfängerin (novice), Erfahren (experienced), Sucher (search) und Nahrungsquelle (food source)) geregelt wird.
- Zu jedem Zeitpunkt wird das Verhalten einer einzelnen Biene durch die ihr zur Verfügung stehenden internen und externen Informationen sowie durch ihren Motivationszustand bestimmt, und zwar gemäß einer Reihe spezifischer Regeln.
- Das Regelwerk ist für jede Biene gleich, aber da die Bienen die Umgebung an verschiedenen Orten unterschiedlich wahrnehmen, ist auch ihr Verhalten unterschiedlich.
- Bienen können je nach ihrer Erfahrung bei der Futtersuche und/oder ihrem Motivationszustand unterschiedliche Verhaltensweisen an den Tag legen.
Das ABHA-Modell stellt also das Verhalten der Bienen als von einer Reihe von Regeln bestimmt dar, die sich an individuelle Merkmale und die Umwelt anpassen.
2. Wiederaufnahme der Implementierung des Algorithmus
Fahren wir fort mit dem Schreiben der Algorithmus-Methoden unter Verwendung des im vorherigen Artikel beschriebenen Pseudocodes.
Die Methode StageActivityNovice steuert, wie Anfänger-Bienen ihre Position ändern, indem sie zufällig suchen oder dem „Tanz“ anderer Agenten folgen. Beschreibung der Methode:
- Parameter - Die Methode akzeptiert einen Verweis auf ein Agentenobjekt vom Typ S_ABHA_Agent, das einen „Anfänger“ im Algorithmus darstellt.
- Rückgabewert - die Methode gibt nichts zurück (void).
Logik der Methode:
1. Die Variable val wird für die Speicherung der aktuellen Koordinate des Agenten deklariert.
2. Die for-Schleife iteriert durch alle Koordinaten des Agenten, wobei coords die Gesamtzahl der Koordinaten (oder Dimensionen) im Suchraum ist.
3. Innerhalb der Schleife wird der Wert der aktuellen Koordinate des Agenten in der Variablen val gespeichert.
4. Abhängig von der Wahrscheinlichkeit wird entschieden, welche Aktion durchgeführt werden soll:
- Zufallssuche - wenn die generierte Zufallszahl (über u.RNDprobab ()) kleiner ist als randomSearchProbability, wird die Zufallssuche durchgeführt und die Koordinate c mit der Methode ActionRandomSearch (c) aktualisiert, die eine neue Position in dieser Dimension erzeugt.
- Dem Tanz folgen - andernfalls wird der Agent dem „Tanz“ anderer Agenten folgen. In diesem Fall wird die Koordinate c mit der Methode ActionFollowingDance (c, val) aktualisiert, die den Wert val zur Bestimmung einer neuen Position auf der Grundlage von Informationen über andere Agenten verwendet.
Die Methode StageActivityNovice steuert das Verhalten von Anfängern im ABHA-Algorithmus und führt letztlich die folgenden Schlüsselaktionen durch:
1. Iteriert durch jede Agentenkoordinate.
2. Abhängig von einer zufälligen Wahrscheinlichkeit entscheidet der Agent, ob er eine zufällige Suche durchführt oder dem „Tanz“ der anderen Agenten folgt.
3. Aktualisiert die Position des Agenten an jeder Koordinate entsprechend der gewählten Aktion.
Diese Methode ermöglicht es Anfängern, sich an die Umgebung anzupassen, indem sie sowohl zufällige Strategien als auch Strategien, die auf der Interaktion mit anderen Agenten basieren, anwenden.
//—————————————————————————————————————————————————————————————————————————————— //Actions 1 or 2 void C_AO_ABHA::StageActivityNovice (S_ABHA_Agent &agent) { double val; for (int c = 0; c < coords; c++) { val = agent.position [c]; if (u.RNDprobab () < randomSearchProbability) agent.position [c] = ActionRandomSearch (c); else agent.position [c] = ActionFollowingDance (c, val); } } //——————————————————————————————————————————————————————————————————————————————
Die Methode StageActivityExperienced der Klasse C_AO_ABHA ist für die Aktionen erfahrener Agenten im ABHA-Algorithmus zuständig und steuert, wie erfahrene Agenten ihre Aktionen in Abhängigkeit von Zufallswahrscheinlichkeiten und ihren aktuellen Strategien wählen.
1. Die Variable rnd wird deklariert. Es soll dazu dienen, eine Zufallszahl zu speichern, die für die Entscheidung über die Aktionen des Agenten generiert wird.
2. Die for-Schleife iteriert durch alle Koordinaten des Agenten, wobei coords die Gesamtzahl der Koordinaten (oder Dimensionen) im Suchraum ist.
3. Innerhalb der Schleife wird die Zufallszahl rnd für jede Koordinate mit Hilfe der Methode RNDprobab () erzeugt, die einen Wert zwischen 0 und 1 zurückgibt.
4. Wenn rnd kleiner oder gleich agent.p_srs (Wahrscheinlichkeit der Zufallssuche) ist, führt der Agent eine Zufallssuche durch und aktualisiert seine Position an der Koordinate c mit der Methode ActionRandomSearch (c).
Die Wahrscheinlichkeit, dem Tanz zu folgen:
- Wenn rnd größer als agent.p_srs und kleiner oder gleich agent.p_rul (Wahrscheinlichkeit, dem Tanz zu folgen) ist, folgt der Agent dem „Tanz“ der anderen Agenten und aktualisiert seine Position mit der Methode ActionFollowingDance (c, agent.position [c]).
Wahrscheinlichkeit des Verbleibs an einer Quelle:
- Wenn keine der vorherigen Bedingungen erfüllt ist, bleibt der Agent in der Nähe der Quelle und aktualisiert seine Position mit Hilfe der ActionHiveVicinity (c, agent.bestPosition [c]), wobei agent.bestPosition [c] die beste bekannte Position des Agenten darstellt.
Die StageActivityExperienced-Methode steuert das Verhalten erfahrener Agenten im ABHA-Algorithmus und bewirkt letztlich Folgendes:
1. Iteriert durch jede Agentenkoordinate.
2. Erzeugt eine Zufallszahl zur Auswahl einer Aktion.
3. Abhängig von der generierten Zahl und den Wahrscheinlichkeiten wird bestimmt, ob der Agent eine zufällige Suche durchführt, dem „Tanz“ der anderen Agenten folgt oder in der Nähe der Quelle bleibt.
Mit dieser Methode können sich erfahrene Agenten mit komplexeren Strategien an die Umgebung anpassen als Anfänger und so ihre Leistung bei der Ressourcensuche verbessern.
//—————————————————————————————————————————————————————————————————————————————— //actions 1 or 2 or 4 void C_AO_ABHA::StageActivityExperienced (S_ABHA_Agent &agent) { double rnd = 0; for (int c = 0; c < coords; c++) { rnd = u.RNDprobab (); // random search probability if (rnd <= agent.p_srs) { agent.position [c] = ActionRandomSearch (c); } else { // Probability of following the dance if (agent.p_srs < rnd && rnd <= agent.p_rul) { agent.position [c] = ActionFollowingDance (c, agent.position [c]); } // Probability of remaining near the source else { agent.position [c] = ActionHiveVicinity (c, agent.bestPosition [c]); } } } } //——————————————————————————————————————————————————————————————————————————————
Die Methode StageActivitySearch der Klasse C_AO_ABHA ist für die Aktionen der Agenten während der Suchphase zuständig und steuert, wie sich die Agenten im Suchraum bewegen, indem sie ihre Positionen je nach der gewählten Richtung aktualisieren. Die Methode geht folgendermaßen vor:
1. Iteriere durch jede Agentenkoordinate.
2. Rufe für jede Koordinate die Methode ActionMovingDirection auf, die die neue Bewegungsrichtung des Agenten bestimmt.
3. Aktualisiere die Position des Agenten an der entsprechenden Koordinate.
Diese Methode ermöglicht es den Agenten, sich aktiv im Suchraum zu bewegen und ihre Position je nach der gewählten Richtung anzupassen.
//—————————————————————————————————————————————————————————————————————————————— //Actions 3 void C_AO_ABHA::StageActivitySearch (S_ABHA_Agent &agent) { for (int c = 0; c < coords; c++) { agent.position [c] = ActionMovingDirection (agent, c); } } //——————————————————————————————————————————————————————————————————————————————
Die StageActivitySource-Methode in der Klasse C_AO_ABHA dient zur Durchführung von Aktionen im Zusammenhang mit der Bestimmung von Nahrungsquellen für Agenten im Modell. Sie aktualisiert die Positionen der Agenten auf der Grundlage ihrer besten Positionen in der Nähe des Bienenstocks. Die Methode führt die folgenden Schritte durch:
1. Initialisiert die Variable val.
2. Iteriere durch jede Agentenkoordinate.
3. Aktualisiert für jede Koordinate die Position des Agenten, indem es die Methode ActionHiveVicinity aufruft, die die neue Position des Agenten auf der Grundlage seiner besten bekannten Position bestimmt.
Diese Methode hilft den Agenten der „Nahrungsquelle“ (food source), ihre gesamte Aufmerksamkeit auf eine detaillierte Erkundung der Umgebung einer bekannten Nahrungsquelle zu richten.
//—————————————————————————————————————————————————————————————————————————————— //Actions 4 void C_AO_ABHA::StageActivitySource (S_ABHA_Agent &agent) { double val = 0; for (int c = 0; c < coords; c++) { agent.position [c] = ActionHiveVicinity (c, agent.bestPosition [c]); } } //——————————————————————————————————————————————————————————————————————————————
Die Methode ActionRandomSearch in der Klasse C_AO_ABHA dient der Durchführung einer Zufallssuche innerhalb eines bestimmten Koordinatenbereichs und ermöglicht es dem Agenten, einen Wert innerhalb eines bestimmten Bereichs zufällig auszuwählen. Die Methode führt eine erweiterte Erkundung des Suchraums durch und führt die folgenden Aktionen aus:
1. Akzeptiert den Index der Koordinate, für die ein Zufallswert erzeugt werden soll.
2. Verwendet eine Methode zur Generierung von Zufallszahlen, um einen Wert innerhalb des Bereichs zu erhalten, der durch die Mindest- und Höchstwerte für eine bestimmte Koordinate definiert ist.
3. Gibt einen zufällig erzeugten Wert vom Typ double zurück.
//—————————————————————————————————————————————————————————————————————————————— //1. Random search (random placement in a range of coordinates) double C_AO_ABHA::ActionRandomSearch (int coordInd) { return u.RNDfromCI (rangeMin [coordInd], rangeMax [coordInd]); } //——————————————————————————————————————————————————————————————————————————————
Die Methode ActionFollowingDance der Klasse C_AO_ABHA implementiert die Logik des Folgens eines Tänzers, was eine Bewegung in Richtung eines Agenten bedeutet, der bereits eine bestimmte Erfahrungsstufe erreicht hat. Diese Methode verwendet einen probabilistischen Ansatz, um den Agenten auszuwählen, dem der aktuelle Agent folgen wird, und fügt der berechneten Richtung zufälliges Rauschen hinzu.
1. Berechnung der Gesamtwahrscheinlichkeit:
- Die initialisierte Variable totalProbability, in der die Summe der Wahrscheinlichkeiten p_si aller „erfahrenen“ Agenten gespeichert wird.
- Der Zustand aller Bearbeiter wird in einer Schleife überprüft. Wenn ein Agent erfahren ist, wird seine Wahrscheinlichkeit zu totalProbability hinzugefügt.
2. Generierung eines Zufallswertes und Auswahl eines Agenten:
- Der Zufallswert randomValue wird generiert. Der Wert wird relativ zu totalProbability normalisiert.
- In der nächsten Schleife werden die Wahrscheinlichkeiten p_si der erfahrenen Agenten akkumuliert. Sobald die kumulierte Wahrscheinlichkeit randomValue übersteigt, wird der Index des ausgewählten Agenten gespeichert und die Schleife unterbrochen.
3. Überprüfung der ausgewählten Belastung und Berechnung des neuen Wertes:
- Wenn kein Agent ausgewählt wurde (ind index ist gleich -1), wird die Methode ActionRandomSearch für eine Zufallssuche aufgerufen.
- Wenn ein Agent ausgewählt wurde, wird die Bewegungsrichtung als Differenz zwischen der besten Position des ausgewählten Agenten und dem aktuellen Wert von val berechnet.
- Das Zufallsrauschen wird im Bereich von -1 bis 1 erzeugt.
- Es wird ein neuer Wert zurückgegeben, der dem aktuellen, um Richtung und Rauschen bereinigten Wert val entspricht.
Die Methode ActionFollowingDance implementiert die Strategie des Folgens erfahrener Agenten (der Agent wird nach der Roulette-Regel ausgewählt, bei der eine erfahrenere tanzende Biene eine höhere Chance hat, ausgewählt zu werden), wobei ein probabilistischer Ansatz zur Auswahl des Agenten verwendet wird und der Bewegungsrichtung zufälliges Rauschen hinzugefügt wird, wodurch das Verhalten der Agenten vielfältiger und anpassungsfähiger wird.
——————————————————————————————————————————————————————————————————————— //2. Follow the dance (move in the direction of the dancer) double C_AO_ABHA::ActionFollowingDance (int coordInd, double val) { //---------------------------------------------------------------------------- double totalProbability = 0; for (int i = 0; i < popSize; i++) { if (agents [i].state == S_ABHA_Agent::stateExperienced) { totalProbability += agents [i].p_si; } } //---------------------------------------------------------------------------- double randomValue = u.RNDprobab () * totalProbability; double cumulativeProbability = 0; int ind = -1; for (int i = 0; i < popSize; i++) { if (agents [i].state == S_ABHA_Agent::stateExperienced) { cumulativeProbability += agents [i].p_si; if (cumulativeProbability >= randomValue) { ind = i; break; } } } //---------------------------------------------------------------------------- if (ind == -1) { return ActionRandomSearch (coordInd); } double direction = agents [ind].bestPosition [coordInd] - val; double noise = u.RNDfromCI (-1.0, 1.0); return val + direction * noise; } //——————————————————————————————————————————————————————————————————————————————
Die Methode ActionMovingDirection der Klasse C_AO_ABHA ist für die Bewegung des Agenten in eine bestimmte Richtung mit einem bestimmten Schritt zuständig. Lassen Sie uns den Code Stück für Stück aufschlüsseln.
1. Bewegung der Agenten:
- Aktualisierung der Position des Agenten an der angegebenen Koordinate coordInd.
- agent.position [coordInd] - aktuelle Position des Agenten an der angegebenen Koordinate.
- agent.stepSize - Schrittweite, um die sich der Agent in diese Richtung bewegt.
- agent.direction [coordInd] - Richtung der Bewegung des Agenten entlang der angegebenen Koordinate.
- Multipliziert man stepSize mit direction, erhält man den Betrag der Bewegung, der zur aktuellen Position des Agenten hinzugefügt wird.
2. Schrittweite verringern:
- Nach der Bewegung wird die Schrittweite stepSize um das Verhältnis stepSizeReductionFactor verringert.
- Dies ist notwendig, um den Effekt der abnehmenden Bewegung zu simulieren, wenn der Agent beginnt, sich langsamer zu bewegen, um die gefundene Lösung zu verfeinern.
Die Methode ActionMovingDirection implementiert eine einfache Logik, bei der sich der Agent unter Berücksichtigung der Schrittweite in eine bestimmte Richtung bewegt und diesen Schritt nach der Bewegung verkleinert.
//—————————————————————————————————————————————————————————————————————————————— //3. Move in a given direction with a step double C_AO_ABHA::ActionMovingDirection (S_ABHA_Agent &agent, int coordInd) { agent.position [coordInd] += agent.stepSize * agent.direction [coordInd]; agent.stepSize *= stepSizeReductionFactor; return agent.position [coordInd]; } //——————————————————————————————————————————————————————————————————————————————
Die Methode ActionHiveVicinity der Klasse C_AO_ABHA dient der Definition des Agentenverhaltens in der Nähe einer Nahrungsquelle. Die Methode ActionHiveVicinity ist für die Erzeugung einer neuen Position an einer bestimmten Koordinate zuständig. Die Wahrscheinlichkeit, dass eine neue Position in der Nähe der aktuellen Position entsteht, ist höher.
//—————————————————————————————————————————————————————————————————————————————— //4. Move in the vicinity of a food source double C_AO_ABHA::ActionHiveVicinity (int coordInd, double val) { return u.PowerDistribution (val, rangeMin [coordInd], rangeMax [coordInd], 12); } //——————————————————————————————————————————————————————————————————————————————
Schauen wir uns die Methode ChangingStateForNovice in der Klasse C_AO_ABHA an, die dafür zuständig ist, den Zustand des Agenten in Abhängigkeit von seinen aktuellen Anpassungskosten und den Informationen über die Nahrungsquelle zu ändern.
1. Der vorherige und der beste Wert werden bei dieser Methode nicht berücksichtigt.
2. Überprüfen des Status:
- Wenn die aktuellen Kosten einer Nahrungsquelle agent.cost den Durchschnittswert avgCost übersteigen, wechselt der Zustand des Agenten zu erfahren stateExperienced. Dies bedeutet, dass der Agent genügend Informationen über hochprofitable Nahrungsquellen erhalten hat und bereit ist, effizienter zu handeln.
3. Wechsel in den Suchstatus:
- Wenn der aktuelle Wert den Durchschnittswert nicht übersteigt, geht der Agent in den Suchzustand stateSearch über. In diesem Zustand wird davon ausgegangen, dass der Agent keine Informationen über Nahrungsquellen hat und eine zufällige Suche beginnen sollte.
4. Zufällige Suchrichtung:
- Der Zyklus durchläuft alle Koordinaten und für jede Koordinate wird eine zufällige Richtung zugewiesen. Die Methode RNDfromCI generiert eine Zufallszahl innerhalb des angegebenen Bereichs und wird verwendet, um den Betrag der Bewegung und die Richtung innerhalb des angegebenen Bereichs (rangeMin und rangeMax) zu bestimmen.
5. Initialisierung der Suchparameter:
- Die Schrittweite wird für die Bewegung des Agenten zusammen mit dem Suchzähler festgelegt, der die Anzahl der Iterationen des Agenten bei der Suche nach Nahrung festhält.
Die Methode ChangingStateForNovice ist dafür zuständig, den Zustand der „Anfängerbiene“ in Abhängigkeit vom Wert ihrer Nahrungsquelle zu ändern. Wenn der Wert hoch ist, wird der Agent erfahren. Wenn der Wert niedrig ist, geht der Agent in den Suchzustand über, startet eine zufällige Suche und initialisiert seine Parameter.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForNovice (S_ABHA_Agent &agent) { //Current cost : Used to enter either the Experienced or Search state. //Previous cost: Not used. //Best cost : Not used. //Into Experienced. If a novice receives information about a highly profitable food source (for example, through dances of other bees), it may transition to the experienced state. //Into Search. If a novice does not receive information about food sources, it may begin a random search and enter a search state. if (agent.cost > avgCost) agent.state = S_ABHA_Agent::stateExperienced; else { agent.state = S_ABHA_Agent::stateSearch; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } //——————————————————————————————————————————————————————————————————————————————
Die Methode ChangingStateForExperienced in der Klasse C_AO_ABHA dient dazu, den Zustand der erfahrenen Bienenagentin in Abhängigkeit von seinen aktuellen und früheren Kostenwerten für die Nahrungsquelle zu steuern. Schauen wir uns die Methode im Detail an.
1. Ändern des Parameters pab:
- Wenn der aktuelle Wert kleiner ist als der vorherige Wert: Die Biene verringert ihre Wahrscheinlichkeit, sich in der Nähe der Futterquelle aufzuhalten (pab). Wenn pab kleiner als 0 wird, wird es auf 0 gesetzt.
- Wenn der aktuelle Wert größer ist als der vorherige: Die Biene erhöht die Wahrscheinlichkeit, sich in der Nähe der Nahrungsquelle aufzuhalten. Wenn pab größer als 1 ist, wird es auf 1 gesetzt.
- Wenn der aktuelle Wert den besten Wert übersteigt, wird die Wahrscheinlichkeit, in der Nähe der Quelle zu bleiben, auf den Maximalwert von 1 gesetzt.
2. Zur Quelle oder zur Suche wechseln:
- Wenn der aktuelle Wert 20 % über dem Bevölkerungsdurchschnitt liegt, geht die Biene in den Zustand der Nahrungsquelle(stateSource) über, d. h. sie hat eine gute Nahrungsquelle gefunden. Die Wahrscheinlichkeit, an der Quelle zu bleiben, wird auf 1 gesetzt.
- Wenn der aktuelle Wert unter dem Durchschnitt liegt: Die Biene geht in den Zustand Sucher (stateSearch) über. Dies signalisiert die Notwendigkeit, nach neuen Nahrungsquellen zu suchen.
3. Zufällige Suchrichtung:
- Beim Übergang in den Zustand „Sucher“: Die Biene erhält zufällige Anweisungen zur Suche nach neuen Nahrungsquellen.
4. Initialisierung der Suchparameter:
- Für die Bewegung des Agenten wird eine Schrittweite festgelegt, zusammen mit dem Suchzähler, der die Anzahl der auf der Suche nach Nahrung zurückgelegten Schritte erfasst.
Die Methode ChangingStateForExperienced steuert den Zustand einer erfahrenen Biene in Abhängigkeit von ihrem aktuellen Futterquellenwert und den vorherigen Werten. Sie verwendet eine Logik, die auf dem Vergleich von aktuellen, vorherigen und besten Werten basiert, um zu entscheiden, ob die Biene eine Nahrungsquelle weiter erforschen oder eine neue suchen soll. Der Parameter pab (die Wahrscheinlichkeit, an der Quelle zu bleiben) wird in Abhängigkeit von der Kostenentwicklung angepasst.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForExperienced (S_ABHA_Agent &agent) { //Current cost : If the current value is high and the information is valid, it can pass this information on to other bees through a dance. //Previous cost: A bee compares the current value with the previous one to determine if the situation has improved. If the current value is better, it may increase the probability of passing the information. //Best cost : A bee can use the best value to assess whether to continue exploring a given food source or to look for a new one. //Into Search. If the information about the current food source is not good enough (e.g. the current fitness value is below the threshold), a bee may enter a search state to search for new sources. //Into Food Source. If information about a food source is confirmed (e.g. the current fitness value is high and stable), a bee may switch to a food source state to analyze the source in more depth. if (agent.cost < agent.prevCost) { agent.pab -= abandonmentRate; if (agent.pab < 0.0) agent.pab = 0.0; } if (agent.cost > agent.prevCost) { agent.pab += abandonmentRate; if (agent.pab > 1.0) agent.pab = 1.0; } if (agent.cost > agent.bestCost) agent.pab = 1.0; if (agent.cost > avgCost * 1.2) { agent.state = S_ABHA_Agent::stateSource; agent.pab = 1; } else if (agent.cost < avgCost) { agent.state = S_ABHA_Agent::stateSearch; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } //——————————————————————————————————————————————————————————————————————————————
Schauen wir uns nun den Code der Methode ChangingStateForSearch aus der Klasse C_AO_ABHA genauer an, die das Verhalten der Bienenagentin bei der Suche nach einer Nahrungsquelle steuert. Die Methode führt die folgenden Schritte durch:
1. Vergleich des aktuellen Wertes mit dem vorherigen Wert:
- Wenn der aktuelle Wert von agent.cost kleiner ist als der vorherige agent.prevCost, bedeutet dies, dass sich die Biene von der Nahrungsquelle entfernt. In diesem Fall
- ändert die Biene ihre Richtung, indem sie mit der Funktion u.RNDfromCI Zufallswerte für jede Koordinatenrichtung erzeugt,
- ist die Biene bereit, die anfängliche Schrittweite initialStepSize ist eingestellt und sie setzt die Erkundung fort.
- ermöglicht die Erhöhung des Suchzählers searchCounter, die Anzahl der Suchversuche zu verfolgen.
2. Der Vergleich des aktuellen Wertes mit dem besten Wert:
- Wenn der aktuelle Wert den von agent.bestCost übersteigt, bedeutet dies, dass die Biene eine profitablere Nahrungsquelle gefunden hat. In diesem Fall
- wird die Schrittweite um das angegebene Verhältnis stepSizeReductionFactor reduziert, was anzeigt, dass ein kleinerer Schritt zur Verfeinerung der gefundenen Lösung erforderlich ist und
- der Suchzähler wird auf 0 zurückgesetzt, weil die Biene eine profitablere Quelle gefunden hat.
3. Überprüfung der maximalen Anzahl von Suchversuchen:
- Erreicht der Suchzähler die maximale Anzahl der Versuche maxSearchAttempts, bedeutet dies, dass die Biene nach einer bestimmten Anzahl von Versuchen nichts Gewinnbringendes gefunden hat. In diesem Fall
- wird der Suchzähler auf 0 zurückgesetzt und
- die Biene geht in den Zustand der Anfängerin (stateNovice). Das bedeutet, dass die Suche erneut gestartet werden sollte.
4. Suche nach einer guten Nahrungsquelle:
- Liegt der aktuelle Wert 20 % über dem Durchschnittswert von avgCost, bedeutet dies, dass die Biene eine gute Nahrungsquelle entdeckt hat. In diesem Fall
- geht die Biene geht in den Zustand Nahrungsquelle (stateSource) über, was bedeutet, dass sie die Rentabilität der Quelle weiter bewerten wird und
- die Wahrscheinlichkeit, in der Nähe der Quelle zu bleiben (pab), wird auf 1 gesetzt. Die Biene wird eher geneigt sein, in der Nähe dieser Quelle zu bleiben.
Die Methode ChangingStateForSearch kontrolliert das Verhalten der Biene im Suchzustand und trifft Entscheidungen auf der Grundlage von Vergleichen der aktuellen, vorherigen und besten Fitnesswerte. Das ermöglicht der Biene, sich an die Umgebung anzupassen und in den Zustand Nahrungsquelle oder Anfänger zu wechseln sowie die Schrittweite je nach gefundenen Nahrungsquellen anzupassen.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForSearch (S_ABHA_Agent &agent) { //Current cost : A bee uses its current fitness value to assess its current position and to decide whether to continue searching or change direction //Previous value: A bee compares the current value with the previous one to determine if things have improved. If the current value is better, it can continue in the same direction. //Best value : The bee uses the best value to determine whether the current food source is more profitable than the previous ones. This helps it make decisions about whether to stay put or continue searching. //Into Food Source. If a searching bee finds a food source with good characteristics (e.g., the current fitness value is better than the threshold), it can switch to the food source state to evaluate the profitability of the source. //Into Novice. If a searching bee does not find any food sources or the information is impractical, it may revert to novice. if (agent.cost < agent.prevCost) { for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter++; } if (agent.cost > agent.bestCost) { agent.stepSize *= stepSizeReductionFactor; agent.searchCounter = 0; } if (agent.searchCounter >= maxSearchAttempts) { agent.searchCounter = 0; agent.state = S_ABHA_Agent::stateNovice; return; } if (agent.cost > avgCost * 1.2) { agent.state = S_ABHA_Agent::stateSource; agent.pab = 1; } } //——————————————————————————————————————————————————————————————————————————————
Die Methode ChangingStateForSource der Klasse C_AO_ABHA steuert das Verhalten der Bienenagentin bei der Erschließung der Nahrungsquelle. Allgemeine Struktur der Methode:
1. Wechsel in den Suchstatus:
- Wenn der aktuelle Wert agent.cost unter avgCost liegt, bedeutet dies, dass die aktuelle Nahrungsquelle nicht rentabel ist.
- Die Biene verringert die Wahrscheinlichkeit, in der Nähe der Quelle zu bleiben (pab), um abandonmentRate, d. h. sie wird weniger wahrscheinlich in der Nähe der aktuellen Quelle bleiben.
- Wenn der aus u.RNDprobab ermittelte Zufallswert agent.pab übersteigt, beschließt die Biene, in den Suchzustand (stateSearch) zu gehen:
- Die Wahrscheinlichkeit wird zurückgesetzt pab = 0.
- Die Biene ändert ihre Richtung, indem sie mit u.RNDfromCI Zufallswerte für jede Koordinate erzeugt.
- Die anfängliche Schrittweite initialStepSize wird gesetzt und der Suchzähler searchCounter wird auf 0 zurückgesetzt.
3. Umzug in den Experienced State:
- Wenn der aktuelle Wert von agent.cost den besten Wert agent.bestCost übersteigt, bedeutet dies, dass sich die aktuelle Nahrungsquelle als rentabel erweist.
- In diesem Fall geht die Biene in den Zustand Erfahren (stateExperienced) über und wird Informationen über eine gute Quelle an andere Bienen weitergeben.
- die Wahrscheinlichkeit, in der Nähe der Quelle zu bleiben (pab), wird auf 1 gesetzt. Die Biene wird mit der größtmöglichen Wahrscheinlichkeit in der Nähe der Quelle bleiben.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForSource (S_ABHA_Agent &agent) { //Current cost : If the current value is below the threshold, it may decide that the source is not good enough and start looking for a new one. //Previous value: The bee can use the previous value to compare and determine if the situation has improved. If the current value is worse, it may signal the need to change the strategy. //Best value : A bee uses the best value to decide whether to continue exploiting the current food source or to look for a new, more profitable one. //Into Search. If the current food source turns out to be impractical (e.g. the current fitness value is worse than the threshold), a bee may switch to a search state to search for new sources. //Into Experienced. If a food source bee finds a food source that proves beneficial, it may enter the experienced state to pass on the information to other bees. if (agent.cost < avgCost) { agent.pab -= abandonmentRate; if (u.RNDprobab () > agent.pab) { agent.state = S_ABHA_Agent::stateSearch; agent.pab = 0; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } if (agent.cost > agent.bestCost) { agent.state = S_ABHA_Agent::stateExperienced; agent.pab = 1; } } //—————————————————————————————————————————————————————————————————————————————
Die Methode CalculateProbabilities in der Klasse C_AO_ABHA ist dafür zuständig, die Wahrscheinlichkeiten verschiedener Aktionen für jeden Agenten (Biene) auf der Grundlage ihrer aktuellen Werte zu berechnen. Die Methode führt die folgenden Schritte durch:
1. Initialisierung von Variablen:
- maxCost wird auf den kleinstmöglichen Wert initialisiert, um sicherzustellen, dass die Kosten eines Agenten größer als dieser Wert sind.
- minCost wird auf einen Maximalwert initialisiert, sodass die Kosten für jeden Agenten unter diesem Wert liegen können.
2. Suchen Sie nach den maximalen und minimalen Kosten:
- Die Schleife durchläuft alle Agenten (Bienen) in der Population popSize.
- Innerhalb der Schleife wird der aktuelle Wert der Belastung mit maxCost und minCost verglichen und die Werte gegebenenfalls aktualisiert.
3. Berechnen des Wertebereichs:
- costRange stellt die Differenz zwischen dem Maximal- und dem Minimalwert dar, was eine Normalisierung der Wahrscheinlichkeiten ermöglicht.
4. Berechnung der Wahrscheinlichkeiten für jeden Agenten:
- p_si - Wahrscheinlichkeit für einen Agenten basierend auf seinen Kosten. Je höher die Kosten, desto höher die Wahrscheinlichkeit (normalisiert nach Reichweite).
- p_srs - im Voraus festgelegte zufällige Suchwahrscheinlichkeit.
- p_rul - Wahrscheinlichkeit, dem Tanz zu folgen. Das heißt, je höher die Wahrscheinlichkeit ist, an der Quelle zu bleiben, desto geringer ist die Wahrscheinlichkeit, dem Tanz zu folgen.
- p_ab - Wahrscheinlichkeit, in der Nähe der Nahrungsquelle zu bleiben, gleich der pab des Agenten.
Danach wird die Summe aller drei Wahrscheinlichkeiten berechnet, und jede von ihnen wird normalisiert, sodass die Summe der Wahrscheinlichkeiten gleich 1 ist. Dazu werden die einzelnen Wahrscheinlichkeiten durch die Gesamtsumme geteilt.
Mit der Methode CalculateProbabilities kann jede Biene ihre Chancen für verschiedene Aktionen (zufällige Suche, Verfolgen eines Tanzes, Auffinden einer Quelle) auf der Grundlage ihrer aktuellen Kosten abschätzen.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::CalculateProbabilities () { double maxCost = -DBL_MAX; double minCost = DBL_MAX; for (int i = 0; i < popSize; i++) { if (agents [i].cost > maxCost) maxCost = agents [i].cost; if (agents [i].cost < minCost) minCost = agents [i].cost; } double costRange = maxCost - minCost; for (int i = 0; i < popSize; i++) { agents [i].p_si = (maxCost - agents [i].cost) / costRange; agents [i].p_srs = randomSearchProbability; // random search probability agents [i].p_rul = 1.0 - agents [i].pab; // probability of following the dance agents [i].p_ab = agents [i].pab; // probability of staying near the source double sum = agents [i].p_srs + agents [i].p_rul + agents [i].p_ab; agents [i].p_srs /= sum; agents [i].p_rul /= sum; agents [i].p_ab /= sum; } } //——————————————————————————————————————————————————————————————————————————————
Die Methode CalculateAverageCost der Klasse C_AO_ABHA dient der Berechnung der Durchschnittskosten aller Bienenagenten in der Population. Diese Informationen sind notwendig, um den Zustand der Population zu analysieren und Entscheidungen im Rahmen des Algorithmus zu treffen. Die Durchschnittskosten dienen als Indikator für den Erfolg der Agenten und werden auch für weitere Berechnungen verwendet.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::CalculateAverageCost () { double totalCost = 0; for (int i = 0; i < popSize; i++) { totalCost += agents [i].cost; } avgCost = totalCost / popSize; } //———————
3. Testergebnisse
ABHA results:
ABHA|Artificial Bee Hive Algorithmus|10.0|10.0|0.1|0.1|0.99|0.5|
=============================
5 Hilly's; Func runs: 10000; result: 0.8413125195861497
25 Hilly's; Func runs: 10000; result: 0.5422730855489947
500 Hilly's; Func runs: 10000; result: 0.2630407626746883
=============================
5 Forest's; Func runs: 10000; result: 0.8785786358650522
25 Forest's; Func runs: 10000; result: 0.47779307049664316
500 Forest's; Func runs: 10000; result: 0.17181208858518054
=============================
5 Megacity's; Func runs: 10000; result: 0.5092307692307693
25 Megacity's; Func runs: 10000; result: 0.3387692307692307
500 Megacity's; Func runs: 10000; result: 0.1039692307692317
=============================
All score: 4.12678 (45.85%)
Wir haben den Code fertig geschrieben und eine detaillierte Analyse aller ABHA-Komponenten durchgeführt. Nun wollen wir den Algorithmus direkt an Testfunktionen ausprobieren und seine Effizienz bewerten. In der Visualisierung des Algorithmus sehen Sie eine ziemlich starke Streuung der Testergebnisse.
ABHA mit der Testfunktion Hilly
ABHA mit der auf der Testfunktion Forest
ABHA mit der auf der Testfunktion Megacity
Aufgrund der Ergebnisse der durchgeführten Untersuchungen nimmt der Algorithmus selbstbewusst einen Platz im Mittelfeld der Bewertungstabelle ein.
# | AO | Beschreibung | Hilly | Hilly final | Forest | Forest final | Megacity (discrete) | Megacity final | Final result | % of MAX | ||||||
| 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | ||||||||
| 1 | ANS | across neighbourhood search | 0.94948 | 0.84776 | 0.43857 | 2.23581 | 1.00000 | 0.92334 | 0.39988 | 2.32323 | 0.70923 | 0.63477 | 0.23091 | 1.57491 | 6.134 | 68.15 |
| 2 | CLA | code lock algorithm | 0.95345 | 0.87107 | 0.37590 | 2.20042 | 0.98942 | 0.91709 | 0.31642 | 2.22294 | 0.79692 | 0.69385 | 0.19303 | 1.68380 | 6.107 | 67.86 |
| 3 | (P+O)ES | (P+O) Entwicklungsstrategien | 0.92256 | 0.88101 | 0.40021 | 2.20379 | 0.97750 | 0.87490 | 0.31945 | 2.17185 | 0.67385 | 0.62985 | 0.18634 | 1.49003 | 5.866 | 65.17 |
| 4 | CTA | Kometenschweif-Algorithmus | 0.95346 | 0.86319 | 0.27770 | 2.09435 | 0.99794 | 0.85740 | 0.33949 | 2.19484 | 0.88769 | 0.56431 | 0.10512 | 1.55712 | 5.846 | 64.96 |
| 5 | SDSm | stochastische Diffusionssuche M | 0.93066 | 0.85445 | 0.39476 | 2.17988 | 0.99983 | 0.89244 | 0.19619 | 2.08846 | 0.72333 | 0.61100 | 0.10670 | 1.44103 | 5.709 | 63.44 |
| 6 | ESG | Entwicklung der sozialen Gruppen | 0.99906 | 0.79654 | 0.35056 | 2.14616 | 1.00000 | 0.82863 | 0.13102 | 1.95965 | 0.82333 | 0.55300 | 0.04725 | 1.42358 | 5.529 | 61.44 |
| 7 | SIA | Simuliertes isotropes Abkühlen | 0.95784 | 0.84264 | 0.41465 | 2.21513 | 0.98239 | 0.79586 | 0.20507 | 1.98332 | 0.68667 | 0.49300 | 0.09053 | 1.27020 | 5.469 | 60.76 |
| 8 | ACS | künstliche, kooperative Suche | 0.75547 | 0.74744 | 0.30407 | 1.80698 | 1.00000 | 0.88861 | 0.22413 | 2.11274 | 0.69077 | 0.48185 | 0.13322 | 1.30583 | 5.226 | 58.06 |
| 9 | TSEA | Schildkrötenpanzer-Evolutionsalgorithmus | 0.96798 | 0.64480 | 0.29672 | 1.90949 | 0.99449 | 0.61981 | 0.22708 | 1.84139 | 0.69077 | 0.42646 | 0.13598 | 1.25322 | 5.004 | 55.60 |
| 10 | DE | differentielle Evolution | 0.95044 | 0.61674 | 0.30308 | 1.87026 | 0.95317 | 0.78896 | 0.16652 | 1.90865 | 0.78667 | 0.36033 | 0.02953 | 1.17653 | 4.955 | 55.06 |
| 11 | CRO | Optimierung chemischer Reaktionen | 0.94629 | 0.66112 | 0.29853 | 1.90593 | 0.87906 | 0.58422 | 0.21146 | 1.67473 | 0.75846 | 0.42646 | 0.12686 | 1.31178 | 4.892 | 54.36 |
| 12 | BSA | Vogelschwarm-Algorithmus | 0.89306 | 0.64900 | 0.26250 | 1.80455 | 0.92420 | 0.71121 | 0.24939 | 1.88479 | 0.69385 | 0.32615 | 0.10012 | 1.12012 | 4.809 | 53.44 |
| 13 | HS | Harmoniesuche | 0.86509 | 0.68782 | 0.32527 | 1.87818 | 0.99999 | 0.68002 | 0.09590 | 1.77592 | 0.62000 | 0.42267 | 0.05458 | 1.09725 | 4.751 | 52.79 |
| 14 | SSG | Setzen, Säen und Wachsen | 0.77839 | 0.64925 | 0.39543 | 1.82308 | 0.85973 | 0.62467 | 0.17429 | 1.65869 | 0.64667 | 0.44133 | 0.10598 | 1.19398 | 4.676 | 51.95 |
| 15 | (PO)ES | (PO) Entwicklungsstrategien | 0.79025 | 0.62647 | 0.42935 | 1.84606 | 0.87616 | 0.60943 | 0.19591 | 1.68151 | 0.59000 | 0.37933 | 0.11322 | 1.08255 | 4.610 | 51.22 |
| 16 | BSO | Brainstorming-Optimierung | 0.93736 | 0.57616 | 0.29688 | 1.81041 | 0.93131 | 0.55866 | 0.23537 | 1.72534 | 0.55231 | 0.29077 | 0.11914 | 0.96222 | 4.498 | 49.98 |
| 17 | WOAm | Wal-Optimierungsalgorithmus M | 0.84521 | 0.56298 | 0.26263 | 1.67081 | 0.93100 | 0.52278 | 0.16365 | 1.61743 | 0.66308 | 0.41138 | 0.11357 | 1.18803 | 4.476 | 49.74 |
| 18 | AEFA | Algorithmus für künstliche elektrische Felder | 0.87700 | 0.61753 | 0.25235 | 1.74688 | 0.92729 | 0.72698 | 0.18064 | 1.83490 | 0.66615 | 0.11631 | 0.09508 | 0.87754 | 4.459 | 49.55 |
| 19 | ACOm | Ameisen-Kolonie-Optimierung M | 0.88190 | 0.66127 | 0.30377 | 1.84693 | 0.85873 | 0.58680 | 0.15051 | 1.59604 | 0.59667 | 0.37333 | 0.02472 | 0.99472 | 4.438 | 49.31 |
| 20 | BFO-GA | Optimierung der bakteriellen Futtersuche - ga | 0.89150 | 0.55111 | 0.31529 | 1.75790 | 0.96982 | 0.39612 | 0.06305 | 1.42899 | 0.72667 | 0.27500 | 0.03525 | 1.03692 | 4.224 | 46.93 |
| 21 | ABHA | Algorithmus für künstliche Bienenstöcke | 0.84131 | 0.54227 | 0.26304 | 1.64663 | 0.87858 | 0.47779 | 0.17181 | 1.52818 | 0.50923 | 0.33877 | 0.10397 | 0.95197 | 4.127 | 45.85 |
| 22 | ASBO | Optimierung des adaptiven Sozialverhaltens | 0.76331 | 0.49253 | 0.32619 | 1.58202 | 0.79546 | 0.40035 | 0.26097 | 1.45677 | 0.26462 | 0.17169 | 0.18200 | 0.61831 | 3.657 | 40.63 |
| 23 | MEC | Evolutionäre Berechnung des Geistes | 0.69533 | 0.53376 | 0.32661 | 1.55569 | 0.72464 | 0.33036 | 0.07198 | 1.12698 | 0.52500 | 0.22000 | 0.04198 | 0.78698 | 3.470 | 38.55 |
| 24 | IWO | Optimierung mit invasiven Unkräutern | 0.72679 | 0.52256 | 0.33123 | 1.58058 | 0.70756 | 0.33955 | 0.07484 | 1.12196 | 0.42333 | 0.23067 | 0.04617 | 0.70017 | 3.403 | 37.81 |
| 25 | Micro-AIS | Künstliches Mikro-Immunsystem | 0.79547 | 0.51922 | 0.30861 | 1.62330 | 0.72956 | 0.36879 | 0.09398 | 1.19233 | 0.37667 | 0.15867 | 0.02802 | 0.56335 | 3.379 | 37.54 |
| 26 | COAm | Kuckuck-Optimierungsalgorithmus M | 0.75820 | 0.48652 | 0.31369 | 1.55841 | 0.74054 | 0.28051 | 0.05599 | 1.07704 | 0.50500 | 0.17467 | 0.03380 | 0.71347 | 3.349 | 37.21 |
| 27 | SDOm | Optimierung der Spiraldynamik M | 0.74601 | 0.44623 | 0.29687 | 1.48912 | 0.70204 | 0.34678 | 0.10944 | 1.15826 | 0.42833 | 0.16767 | 0.03663 | 0.63263 | 3.280 | 36.44 |
| 28 | NMm | Nelder-Mead-Verfahren M | 0.73807 | 0.50598 | 0.31342 | 1.55747 | 0.63674 | 0.28302 | 0.08221 | 1.00197 | 0.44667 | 0.18667 | 0.04028 | 0.67362 | 3.233 | 35.92 |
| 29 | FAm | Firefly-Algorithmus M | 0.58634 | 0.47228 | 0.32276 | 1.38138 | 0.68467 | 0.37439 | 0.10908 | 1.16814 | 0.28667 | 0.16467 | 0.04722 | 0.49855 | 3.048 | 33.87 |
| 30 | GSA | Algorithmus für die Schwerkraftsuche | 0.64757 | 0.49197 | 0.30062 | 1.44016 | 0.53962 | 0.36353 | 0.09945 | 1.00260 | 0.32667 | 0.12200 | 0.01917 | 0.46783 | 2.911 | 32.34 |
| 31 | BFO | Optimierung der bakteriellen Futtersuche | 0.61171 | 0.43270 | 0.31318 | 1.35759 | 0.54410 | 0.21511 | 0.05676 | 0.81597 | 0.42167 | 0.13800 | 0.03195 | 0.59162 | 2.765 | 30.72 |
| 32 | ABC | Künstliches Bienenvolk (Artificial Bee Colony, ABC) | 0.63377 | 0.42402 | 0.30892 | 1.36671 | 0.55103 | 0.21874 | 0.05623 | 0.82600 | 0.34000 | 0.14200 | 0.03102 | 0.51302 | 2.706 | 30.06 |
| 33 | BA | Fledermaus-Algorithmus | 0.59761 | 0.45911 | 0.35242 | 1.40915 | 0.40321 | 0.19313 | 0.07175 | 0.66810 | 0.21000 | 0.10100 | 0.03517 | 0.34617 | 2.423 | 26.93 |
| 34 | SA | simuliertes Abkühlen | 0.55787 | 0.42177 | 0.31549 | 1.29513 | 0.34998 | 0.15259 | 0.05023 | 0.55280 | 0.31167 | 0.10033 | 0.02883 | 0.44083 | 2.289 | 25.43 |
| 35 | IWDm | intelligente Wassertropfen M | 0.54501 | 0.37897 | 0.30124 | 1.22522 | 0.46104 | 0.14704 | 0.04369 | 0.65177 | 0.25833 | 0.09700 | 0.02308 | 0.37842 | 2.255 | 25.06 |
| 36 | PSO | Partikelschwarmoptimierung | 0.59726 | 0.36923 | 0.29928 | 1.26577 | 0.37237 | 0.16324 | 0.07010 | 0.60572 | 0.25667 | 0.08000 | 0.02157 | 0.35823 | 2.230 | 24.77 |
| 37 | Gebote | Boids-Algorithmus | 0.43340 | 0.30581 | 0.25425 | 0.99346 | 0.35718 | 0.20160 | 0.15708 | 0.71586 | 0.27846 | 0.14277 | 0.09834 | 0.51957 | 2.229 | 24.77 |
| 38 | MA | Affen-Algorithmus | 0.59107 | 0.42681 | 0.31816 | 1.33604 | 0.31138 | 0.14069 | 0.06612 | 0.51819 | 0.22833 | 0.08567 | 0.02790 | 0.34190 | 2.196 | 24.40 |
| 39 | SFL | schlurfender Froschsprung | 0.53925 | 0.35816 | 0.29809 | 1.19551 | 0.37141 | 0.11427 | 0.04051 | 0.52618 | 0.27167 | 0.08667 | 0.02402 | 0.38235 | 2.104 | 23.38 |
| 40 | FSS | Fischschulsuche | 0.55669 | 0.39992 | 0.31172 | 1.26833 | 0.31009 | 0.11889 | 0.04569 | 0.47467 | 0.21167 | 0.07633 | 0.02488 | 0.31288 | 2.056 | 22.84 |
| 41 | RND | zufällig | 0.52033 | 0.36068 | 0.30133 | 1.18234 | 0.31335 | 0.11787 | 0.04354 | 0.47476 | 0.25333 | 0.07933 | 0.02382 | 0.35648 | 2.014 | 22.37 |
| 42 | GWO | Grauer-Wolf-Optimierung | 0.59169 | 0.36561 | 0.29595 | 1.25326 | 0.24499 | 0.09047 | 0.03612 | 0.37158 | 0.27667 | 0.08567 | 0.02170 | 0.38403 | 2.009 | 22.32 |
| 43 | CSS | Suche geladener Systeme | 0.44252 | 0.35454 | 0.35201 | 1.14907 | 0.24140 | 0.11345 | 0.06814 | 0.42299 | 0.18333 | 0.06300 | 0.02322 | 0.26955 | 1.842 | 20.46 |
| 44 | EM | elektromagnetismusähnlicher Algorithmus | 0.46250 | 0.34594 | 0.32285 | 1.13129 | 0.21245 | 0.09783 | 0.10057 | 0.41085 | 0.15667 | 0.06033 | 0.02712 | 0.24412 | 1.786 | 19.85 |
Zusammenfassung
Der ABHA-Algorithmus wurde ausgiebig an verschiedenen Testfunktionen getestet und die Ergebnisse haben gezeigt, dass er mit anderen auf Schwarmintelligenz basierenden Algorithmen konkurrenzfähig ist. Bei diesen Tests stellte ABHA seine Effizienz und Zuverlässigkeit unter Beweis.
Die Studien verdeutlichen das Potenzial des ABHA-Algorithmus, nicht nur traditionelle Optimierungsprobleme, sondern auch komplexere Probleme, wie Mehrzieloptimierung und Probleme mit Einschränkungen, zu lösen. Ich hatte jedoch beeindruckendere Ergebnisse erwartet. Unabhängig davon sind die Ergebnisse von ABHA unter den Schwarmalgorithmen wirklich konkurrenzlos.
Im Allgemeinen kann der Algorithmus als eine Reihe spezifischer Methoden und Techniken bewertet werden, die auf die große Mehrheit anderer Optimierungsalgorithmen anwendbar sind. Die Fähigkeit zur Reproduzierbarkeit der Ergebnisse und zur Anpassung an unterschiedliche Bedingungen macht diesen Algorithmus zu einem vielversprechenden Werkzeug im Bereich der rechnergestützten Optimierung. ABHA erweitert also nicht nur den Anwendungsbereich von Optimierungsalgorithmen, sondern eröffnet auch neue Möglichkeiten für die Forschung im Bereich der künstlichen Intelligenz und deren praktische Anwendung.
Abbildung 1. Farbliche Abstufung der Algorithmen entsprechend den relevanten Tests Ergebnisse größer oder gleich 0,99 sind weiß hervorgehoben
Abbildung 2. Das Histogramm der Algorithmus-Testergebnisse (auf einer Skala von 0 bis 100, je mehr, desto besser,
wobei 100 das maximal mögliche, theoretische Ergebnis ist; das Archiv enthält ein Skript zur Berechnung der Bewertungstabelle)
ABHA Pro und Kontra:
Vorteile:
- Gute Ergebnisse bei niedrigdimensionalen Problemen.
- Gute Ergebnisse bei diskreten Funktionen.
Nachteile
- Komplexe Logik und Implementierung von Algorithmen.
- Geringe Konvergenz bei hochdimensionalen Problemen mit glatten Funktionen.
- Eine große Anzahl von externen Parametern.
Der Artikel wird von einem Archiv mit den aktuellen Versionen der Codes der Algorithmem begleitet. Der Autor des Artikels übernimmt keine Verantwortung für die absolute Richtigkeit der Beschreibung der kanonischen Algorithmen. An vielen von ihnen wurden Änderungen vorgenommen, um die Suchmöglichkeiten zu verbessern. Die in den Artikeln dargelegten Schlussfolgerungen und Urteile beruhen auf den Ergebnissen der Versuche.
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/15486
Neuronale Netze im Handel: Leichtgewichtige Modelle für die Zeitreihenprognose
Neuronale Netze im Handel: Verringerung des Speicherverbrauchs mit der Adam-mini-Optimierung
Von der Grundstufe bis zur Mittelstufe: Variablen (III)
Künstlicher Bienenstock-Algorithmus (ABHA): Theorie und Methoden
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Sehen Sie sich den neuen Artikel an: Künstlicher Bienenstock-Algorithmus (ABHA): Tests und Ergebnisse.
Autor: Andrej Dik
Hallo Andrej. Ich kenne diesen Algorithmus seit über 10 Jahren, und er wurde als einer der besten in der Familie der Ameisenalgorithmen angesehen.
Die Ergebnisse liegen unter den Erwartungen.
Hallo Andrei. ich kenne diesen Algorithmus seit mehr als 10 Jahren, und er wurde als einer der besten in der Familie der Ameisenalgorithmen angesehen.
Die Ergebnisse waren niedriger als erwartet. mit Respekt.
Hallo. Ja, das kommt vor. Zum Beispiel stellt sich derselbe PSO als viel schwächer heraus, als man denkt. Es gibt auch Situationen, in denen Entwickler behaupten, die Suchfähigkeiten ihrer Algorithmen seien überschätzt worden, aber in der Praxis stellt sich das Gegenteil heraus. Dies ist eines der Ziele meiner Artikel - echte und reproduzierbare Ergebnisse zu den bekanntesten Optimierungsalgorithmen zu liefern.
Es gibt mehrere Variationen von Algorithmen zum Thema "Bienen", dieser ist einer der stärksten unter ihnen.
Hallo. Ja, das kommt vor. Zum Beispiel stellt sich ein und dasselbe PSO als viel schwächer heraus, als man es glaubt. Es gibt auch Situationen, in denen Entwickler behaupten, dass die Suchfähigkeiten ihrer Algorithmen überschätzt werden, aber in der Praxis stellt sich das Gegenteil heraus. Dies ist eines der Ziele meiner Artikel - wahre und reproduzierbare Ergebnisse der bekanntesten Optimierungsalgorithmen zu liefern.
Es gibt mehrere Variationen von Algorithmen zum Thema "Bienen", dieser ist einer der stärksten unter ihnen.
Die Ans (Across Neighbourhood Search) ist so etwas wie die Crème de la Crème
Ans (Across Neighbourhood Search) ist das Nonplusultra der Branche.