Biogeografisch basierte Optimierung (BBO)
76
0
Inhalt
Einführung
Bei der Durchsicht verschiedener Optimierungsalgorithmen stieß ich auf den Algorithmus „Biogeography-Based Optimization“ (BBO), der 2008 von Professor Dan Simon entwickelt wurde. BBO lässt sich von der Biogeografie inspirieren, der Wissenschaft, die sich mit der geografischen Verbreitung biologischer Organismen befasst. Mathematische Modelle zur Beschreibung der Verbreitungsmuster von Arten wurden erstmals in den 1960er Jahren entwickelt. So wie genetische Algorithmen von der biologischen Genetik und neuronale Netze von biologischen Neuronen inspiriert wurden, nutzt BBO die mathematischen Prinzipien der Biogeografie zur Lösung von Optimierungsproblemen.
In der Natur weisen Inseln eines Archipels mit günstigen Bedingungen (hoher Habitat-Eignungsindex – HSI) eine große Artenvielfalt und eine hohe Auswanderung auf, während Inseln mit ungünstigen Bedingungen nur wenige Arten und eine hohe Einwanderung aufweisen. Diese natürliche Dynamik der Artenmigration zwischen Inseln bildete die Grundlage für den BBO-Optimierungsmechanismus. Der Algorithmus nutzt das Konzept der Artenmigration, um Merkmale zwischen Lösungen auszutauschen; die Mutationswahrscheinlichkeit basiert auf einem theoretisch fundierten Modell zur Artenverteilung, und gute Lösungen geben ihre Merkmale aktiv weiter, bleiben dabei jedoch robust gegenüber Veränderungen. Diese Eigenschaft ist eines der charakteristischen Merkmale des Algorithmus.
In diesem Artikel untersuchen wir dieses elegante algorithmische Konzept, setzen es in Code um und bewerten die Leistungsfähigkeit des BBO-Algorithmus.
Implementierung des Algorithmus
Man stelle sich Inselgruppen vor, auf denen jede Insel verschiedenen Tierarten ein Zuhause bietet.
1. Habitat = Insel = Problemlösung. Jede Insel in unserem Algorithmus steht für eine mögliche Lösung. Wenn es 50 Inseln gibt, dann gibt es 50 verschiedene Lösungen.
2. HSI (Habitat Suitability Index) = Eignung einer Insel als Habitat = Qualität der Lösung. Eine Insel mit reichlich Süßwasser, Obst und einem angenehmen Klima = eine gute Lösung (hoher HSI). Eine karge Insel ohne Wasser = schlechte Lösung (niedriger HSI)
3. Arten = Lösungsmerkmale. Eine ressourcenreiche Insel beherbergt viele Arten, während eine ressourcenarme Insel nur wenige beherbergt, da ihr Habitat weniger vielfältig ist.
Wie funktioniert Migration? Beispiel aus der Praxis: Hawaii (die „reiche Insel“), viele Arten → Tiere schwimmen oder fliegen oft auf andere Inseln (hohe Auswanderung), aber nur wenige schwimmen auf die Insel (geringe Einwanderung – die Insel ist bereits überbevölkert). Unbewohnte Insel: wenige Arten → Tiere verlassen die Insel selten (geringe Abwanderung), aber es kommen oft neue hinzu (hohe Einwanderung – viel freier Platz).
Im Algorithmus: Schlechte Lösung (wenige Arten) → Hohe Einwanderung → nimmt Merkmale guter Lösungen an. Gute Lösung (viele Arten) → Hohe Auswanderung → gibt ihre Merkmale an andere weiter.
Ein weiteres Beispiel aus dem Alltag: Nehmen wir an, wir suchen nach dem besten Standort für ein Geschäft in der Stadt. Jede „Insel“ ist eine Standortoption. Wir erzeugen 50 zufällige Orte (Inseln), davon:
Insel 1: Schlechter Ort – Randbezirk
Insel 2: Großartige Lage – im Zentrum
Insel 50: Ein durchschnittlich guter Ort
Bewerten wir nun jeden Standort (HSI): Insel 2 (Zentrum): HSI = 95 (hoher Kundenverkehr, gute Erreichbarkeit), Insel 1 (Randbezirk): HSI = 20 (wenige Kunden), dann weist Insel 1 (schlecht) eine hohe Einwanderung auf und „übernimmt“ einige Merkmale von Insel 2 (gut). Wenn sich beispielsweise Insel 2 „in der Nähe einer U-Bahn-Station“ befindet, wird auch Insel 1 versuchen, einen Ort in der Nähe einer U-Bahn-Station zu finden. Manchmal können „Katastrophen“ (Erdbeben, Tsunamis) eintreten, wenn sich die Lösung zufällig ändert – das Geschäft „springt“ an einen völlig neuen Ort, und diese Bewegung hilft dabei, unerwartet gute Lösungen zu finden.
Warum mutieren durchschnittliche Lösungen seltener? In der Natur sind sehr ressourcenreiche Inseln (wie die Galapagosinseln) selten und instabil, während sehr artenarme Inseln ebenfalls selten und instabil sind; Inseln mit durchschnittlicher Artenvielfalt hingegen sind am häufigsten anzutreffen und am stabilsten. Im Algorithmus bedeutet dies:
Sehr gute Lösungen (HSI = 95): hohe Mutationswahrscheinlichkeit
Sehr schlechte Lösungen (HSI = 5): hohe Mutationswahrscheinlichkeit
Durchschnittliche Lösungen (HSI = 50): geringe Mutationswahrscheinlichkeit
Die ersten beiden besten Inseln (Lösungen) sind vor Änderungen geschützt – das sind unsere geschützten „Reservelösungen“. Wir wollen die besten Lösungen, die wir gefunden haben, nicht verlieren! Der abschließende Optimierungsprozess sieht dann wie folgt aus: Wir generieren 50 zufällige Lösungen (Inseln), sortieren sie nach ihrer Qualität (von der besten zur schlechtesten), dann lernen die schlechten Lösungen von den guten, und einige Lösungen werden zufällig verändert. Auf diese Weise simuliert BBO den natürlichen Prozess der Artenverbreitung zwischen Inseln, um eine optimale Lösung zu finden. Im Folgenden sehen Sie eine Darstellung der Funktionsweise des Algorithmus.
Abb. 1. Der BBO-Algorithmus in Aktion
Das Diagramm zeigt:
- Drei Arten von Inseln – (artenreich, mittel, artenarm) mit unterschiedlicher Artenanzahl
- Migration – Pfeile zeigen, wie sich Arten zwischen den Inseln bewegen
- Schrittweise Optimierung – von der Initialisierung bis zur Wiederholung
- Schlüsselbegriffe – Legende und grundlegende Algorithmusprinzipien
Die Abbildung veranschaulicht deutlich, dass ressourcenreiche Inseln (gute Lösungen) eine hohe Abwanderung aufweisen, während arme Inseln (schlechte Lösungen) eine hohe Einwanderung verzeichnen, dass ein Austausch von Merkmalen zwischen den Lösungen stattfindet und der gesamte Optimierungszyklus funktioniert. Formulieren wir nun den Pseudocode.
1. INITIALISIERUNG:
– Lege die Parameter fest:
* Populationsgröße (Anzahl der Habitate) = 50
* maximale Einwanderungsrate I = 1,0
* maximale Auswanderungsrate E = 1,0
* Mutationswahrscheinlichkeit = 0,01
* Anzahl der Elite-Lösungen = 2
* maximale Anzahl an Arten = 50
* Anzahl der Iterationen
– Erzeuge eine Population aus N zufälligen Habitaten (Lösungen)
– Berechne den HSI (Eignungsindex) für jedes Habitat
– Berechne die Existenzwahrscheinlichkeiten für verschiedene Artenzahlen
2. HAUPTSCHLEIFE (eine bestimmte Anzahl von Durchläufen wiederholen):
2.1. BEWERTUNG UND SORTIERUNG:
– Berechne den HSI für jedes Habitat
– Sortiere die Habitate nach absteigendem HSI-Wert
– Speichere die beste Lösung
2.2. BERECHNUNG DER MIGRATIONSPARAMETER:
Für jedes Habitat i:
– Bestimme die Anzahl der Arten: Si = Smax × (N - rank_i) / N
– Berechne die Einwanderungsrate: λi = I × (1 - Si/Smax)
– Berechne die Abwanderungsrate: μi = E × (Si/Smax)
– Bestimme die Existenzwahrscheinlichkeit auf der Grundlage von Si
2.3. MIGRATION (Austausch von Merkmalen):
Für jedes Habitat Hi (außer Elite):
WENN Zufallszahl < λi (Einwanderungsrate), DANN:
Für jede Entscheidungsvariable (SIV) j:
WENN Zufallszahl < λi, DANN:
– Wähle ein Spenderhabitat aus:
* Berechne die Summe aller Abwanderungsquoten (außer Hi)
* Wende eine Roulette-Selektion auf der Grundlage von μ an
* Wähle das Habitat Hk mit der Wahrscheinlichkeit von μk/Σμ
– Kopiere die j-te Variable von Hk nach Hi
ENDE WENN
ENDE der Schleife für Variablen
ENDE WENN
ENDE des Zyklus in Bezug auf Habitate
2.4. MUTATION (Erforschung neuer Lösungen):
Für jedes Habitat Hi (außer Elite):
– Berechne die Mutationsrate: m_rate = m × (1 - Wahrscheinlichkeit_der_Existenz_i)
WENN random_number < m_rate, DANN:
– Wähle eine Zufallsvariable j
– Ersetze sie durch einen Zufallswert aus dem zulässigen Bereich
ENDE WENN
ENDE des Zyklus in Bezug auf Habitate
2.5. ERSETZUNG UND AKTUALISIERUNG:
– Neue HSI-Werte berechnen
– Aktualisiere die gefundene beste Lösung
– Speichere die aktuellen Fitnesswerte für die nächste Iteration
3. RÜCKGABE der besten gefundenen Lösung
Nun müssen wir nur noch die Klasse C_AO_BBO implementieren, die von der Klasse C_AO abgeleitet wird und zur Umsetzung des BBO-Algorithmus dient. Die Vererbung bedeutet, dass C_AO_BBO die von der übergeordneten Klasse bereitgestellten Grundfunktionen zur Optimierung nutzt.
Die Klasse enthält eine Reihe von Parametern, darunter die Populationsgröße sowie BBO-spezifische Parameter wie die maximale Einwanderungs-/Auswanderungsrate (immigrationMax, emigrationMax), Mutationswahrscheinlichkeit (mutationProb), Anzahl der unverändert beibehaltenen Elite-Lösungen (elitismCount) und maximale Anzahl von Arten (speciesMax). Der Klassenkonstruktor initialisiert die BBO-Parameter mit Standardwerten, weist einen Namen und eine Beschreibung zu und fügt einen Link zu einem Artikel über den Algorithmus hinzu. Mit der Methode SetParams() können die Werte von Parametern anhand der Daten aus dem Array „params“ geändert werden.
Wichtigste Methoden:- Init() – initialisiert den Algorithmus, einschließlich der Erstellung und Initialisierung der Population, der Festlegung der Wertebereiche, des Schritts und der Anzahl der Epochen sowie der Initialisierung der Arrays zum Speichern der Habitatdaten.
- Moving() — implementiert die grundlegende Logik für das Verschieben (Migrieren) von Lösungen zwischen Habitaten gemäß den BBO-Prinzipien.
- Revision() – aktualisiert die aktuell beste gefundene Lösung (Habitate).
- S_HabitatData – interne Struktur, die Informationen zu jedem Habitat (Lösung) enthält, darunter die Anzahl der Arten (speciesCount), die Einwanderungs-/Auswanderungsrate (immigration, emigration) und die Existenzwahrscheinlichkeit (probability).
- habitatData – Ein Array der Struktur S_HabitatData, das Daten zu jedem Habitat der Population speichert.
- probabilities – Array mit Wahrscheinlichkeiten, die für die Mutation verwendet werden.
Private Methoden enthalten die Implementierung der wichtigsten Schritte des BBO-Algorithmus, wie beispielsweise die Initialisierung der Population, die Berechnung der Migrationsraten und die Mutation.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_BBO : public C_AO { public: //-------------------------------------------------------------------- ~C_AO_BBO () { } C_AO_BBO () { ao_name = "BBO"; ao_desc = "Biogeography-Based Optimization"; ao_link = "https://www.mql5.com/en/articles/18354"; popSize = 50; // population size (number of habitats) immigrationMax = 1.0; // maximum immigration rate emigrationMax = 1.0; // maximum emigration rate mutationProb = 0.5; // mutation probability elitismCount = 2; // number of elite solutions speciesMax = 50; // maximum number of species ArrayResize (params, 6); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "immigrationMax"; params [1].val = immigrationMax; params [2].name = "emigrationMax"; params [2].val = emigrationMax; params [3].name = "mutationProb"; params [3].val = mutationProb; params [4].name = "elitismCount"; params [4].val = elitismCount; params [5].name = "speciesMax"; params [5].val = speciesMax; } void SetParams () { popSize = (int)params [0].val; immigrationMax = params [1].val; emigrationMax = params [2].val; mutationProb = params [3].val; elitismCount = (int)params [4].val; speciesMax = (int)params [5].val; } bool Init (const double &rangeMinP [], // minimum values const double &rangeMaxP [], // maximum values const double &rangeStepP [], // step change const int epochsP = 0); // number of epochs void Moving (); void Revision (); //---------------------------------------------------------------------------- double immigrationMax; // maximum immigration rate double emigrationMax; // maximum emigration rate double mutationProb; // mutation probability int elitismCount; // number of elite solutions int speciesMax; // maximum number of species private: //------------------------------------------------------------------- struct S_HabitatData { int speciesCount; // number of species in the habitat double immigration; // immigration rate double emigration; // emigration rate double probability; // probability of existence }; S_HabitatData habitatData []; // data for each habitat double probabilities []; // probabilities for counting mutations // Auxiliary methods void InitializePopulation (); void CalculateRates (); void Migration (); void Mutation (); double CalculateProbability (int speciesCount); }; //——————————————————————————————————————————————————————————————————————————————
Die Methode Init konfiguriert den BBO-Algorithmus, bevor dieser seine Arbeit aufnimmt. Sie führt grundlegende Initialisierungsschritte (Prüfungen und Einstellungen) durch und reserviert Speicher für die Daten der Habitate und für die Migrationswahrscheinlichkeiten. Anschließend berechnet und normiert es die Migrationswahrscheinlichkeiten auf der Grundlage der Anzahl der Arten in jedem Habitat. Gibt bei Erfolg true zurück.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_BBO::Init (const double &rangeMinP [], // minimum values const double &rangeMaxP [], // maximum values const double &rangeStepP [], // step change const int epochsP = 0) // number of epochs { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; //---------------------------------------------------------------------------- // Initialize arrays for each habitat ArrayResize (habitatData, popSize); ArrayResize (probabilities, speciesMax + 1); // Calculate probabilities for different numbers of species double sum = 0.0; for (int i = 0; i <= speciesMax; i++) { probabilities [i] = CalculateProbability (i); sum += probabilities [i]; } // Normalization of probabilities if (sum > 0) { for (int i = 0; i <= speciesMax; i++) { probabilities [i] /= sum; } } return true; } //——————————————————————————————————————————————————————————————————————————————
Die Methode „Moving“ implementiert den Hauptoptimierungszyklus des BBO-Algorithmus. Beim ersten Aufruf der Methode wird das „Revision“-Flag überprüft. Wenn der Wert angibt, dass die Population noch nicht erstellt wurde, wird sie initialisiert. Dazu gehören die Erzeugung von Zufallslösungen, die Bewertung ihrer Eignung und die Festlegung der Anfangsparameter. Danach wird das Flag auf true gesetzt.
Sobald die Initialisierung abgeschlossen ist, wird eine Reihe von Schritten ausgeführt, die für einen algorithmischen Zyklus charakteristisch sind: Die Lösungsmenge wird nach ihrem Fitnesswert sortiert, um die besten und schlechtesten Agenten zu ermitteln. Dies erleichtert die Verwaltung von Migrationen und Mutationen. In dieser Phase werden die Wahrscheinlichkeiten und Raten des Artenaustauschs zwischen Habitaten auf der Grundlage ihres aktuellen Zustands und der Qualität ihrer Entscheidungen berechnet. Diese Parameter bestimmen, wie Arten von einem Habitat in ein anderes „wandern“. In diesem Schritt findet der Austausch von SIV zwischen den Habitaten statt.
Infolgedessen erhalten Habitate mit geringer Artenvielfalt neue Arten aus artenreicheren Habitaten, was die Erkundung des Lösungsraums erleichtert. Nach der Migration treten zufällige Veränderungen in den Lösungen (Mutationen) auf, um die genetische Vielfalt zu erhalten. Die Mutationswahrscheinlichkeiten können vom aktuellen Zustand der Lösung und von den Algorithmusparametern abhängen. Am Ende der Schleife werden die aktuellen Werte der Lösungs-Fitnessfunktion gespeichert, damit sie in der nächsten Iteration des Algorithmus für die Sortierung und Analyse verwendet werden können.
//+----------------------------------------------------------------------------+ //| Basic optimization method | //+----------------------------------------------------------------------------+ void C_AO_BBO::Moving () { // First iteration - initialization of the initial population if (!revision) { InitializePopulation (); revision = true; return; } // Main optimization // 1. Sort the population by HSI (fitness) static S_AO_Agent aTemp []; ArrayResize (aTemp, popSize); u.Sorting (a, aTemp, popSize); // 2. Calculate immigration and emigration rates CalculateRates (); // 3. Migration (exchange of SIVs between habitats) Migration (); // 4. Probability-based mutation Mutation (); // 5. Save state for the next iteration for (int i = 0; i < popSize; i++) { a [i].fP = a [i].f; } } //——————————————————————————————————————————————————————————————————————————————
Die Revisionsmethode dient dazu, die derzeit beste Lösung in der Population zu aktualisieren. Es durchläuft alle Agenten (Lösungen) der aktuellen Population und vergleicht deren Wert der Fitnessfunktion mit dem in der Variablen fB gespeicherten Wert, in dem das derzeit beste Ergebnis gespeichert ist.
Wenn ein Agent einen Wert für die Fitnessfunktion hat, der besser ist als der derzeit beste, ersetzt er diesen Wert, und die entsprechenden Lösungsparameter werden in die Variable kopiert, in der die beste Lösung gespeichert ist. Daher enthält die Variable nach Ausführung der Methode immer die beste gefundene Lösung.
//+----------------------------------------------------------------------------+ //| Update the best solution | //+----------------------------------------------------------------------------+ void C_AO_BBO::Revision () { // Find the best solution in the current population for (int i = 0; i < popSize; i++) { // Update the best solution if (a [i].f > fB) { fB = a [i].f; ArrayCopy (cB, a [i].c, 0, 0, WHOLE_ARRAY); } } } //——————————————————————————————————————————————————————————————————————————————
Die Methode „InitializePopulation“ ist dafür zuständig, die Anfangspopulation von Lösungen für den BBO-Algorithmus zu erstellen. Es erzeugt popSize (Populationsgröße) Individuen (Habitate), die gleichmäßig über den Suchraum verteilt sind.
Für jede einzelne Instanz generiert die Methode zufällige Koordinaten (Werte der Lösungsparameter) innerhalb der Grenzen, die durch die Arrays „rangeMin“ (Mindestgrenzen) und „rangeMax“ (Höchstgrenzen) für jede „coords“-Koordinate festgelegt sind. Die Funktion u.RNDfromCI dient dazu, eine Zufallszahl in einem vorgegebenen Bereich zu erzeugen.
Anschließend rundet die Methode die generierten Koordinaten auf den nächsten gültigen Schritt, der durch das Array „rangeStep“ definiert ist. Dadurch wird sichergestellt, dass sich die Lösungen in einem zulässigen diskreten Suchraum befinden. Hierfür wird die Funktion SeInDiSp verwendet. Nach der Initialisierung der Koordinaten initialisiert die Methode für jedes Individuum die Datenstruktur „habitatData“ und setzt dabei die Werte für „speciesCount“, „immigration“, „emigration“ und „probability“ auf Null. Diese Werte werden bei der Optimierung zur Berechnung der Einwanderungs- und Auswanderungsraten sowie der Mutationswahrscheinlichkeiten herangezogen.
//+----------------------------------------------------------------------------+ //| Initialize the initial population | //+----------------------------------------------------------------------------+ void C_AO_BBO::InitializePopulation () { // Initialize the initial population uniformly throughout the space for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { // Generate random coordinates within acceptable limits a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); // Round to the nearest acceptable step a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } // Initialize habitat data habitatData [i].speciesCount = 0; habitatData [i].immigration = 0.0; habitatData [i].emigration = 0.0; habitatData [i].probability = 0.0; } } //——————————————————————————————————————————————————————————————————————————————
Die Methode „CalculateRates“ dient dazu, die Migrationsraten (Einwanderung und Auswanderung) sowie die Wahrscheinlichkeit des Vorkommens jedes Habitats in der Population zu berechnen.
Es wird ein lineares Modell verwendet, bei dem die Anzahl der Arten, die jeder Lösung zugeordnet werden, proportional zu deren Rang bestimmt wird, wobei bessere Lösungen mehr Arten aufweisen. Die Einwanderungsrate nimmt mit steigender Artenzahl ab – je mehr Arten eine Population umfasst, desto geringer ist die Wahrscheinlichkeit, dass sie neue Individuen aufnimmt. Die Auswanderungsrate steigt mit der Anzahl der Arten – je mehr Arten eine Lösung umfasst, desto höher ist die Wahrscheinlichkeit, dass sie verlassen wird.
Die Wahrscheinlichkeit der Existenz eines Habitats wird auf der Grundlage vorab festgelegter Wahrscheinlichkeiten für die jeweilige Artenanzahl ermittelt. Übersteigt die Anzahl der Arten die zulässige Höchstgrenze, wird die Wahrscheinlichkeit auf Null gesetzt.
//+----------------------------------------------------------------------------+ //| Calculate immigration and emigration rates | //+----------------------------------------------------------------------------+ void C_AO_BBO::CalculateRates () { // For the linear migration model for (int i = 0; i < popSize; i++) { // The number of species is inversely proportional to the rank (the best solutions have more species) habitatData [i].speciesCount = speciesMax - (i * speciesMax / popSize); // The rate of immigration decreases as the number of species increases habitatData [i].immigration = immigrationMax * (1.0 - (double)habitatData [i].speciesCount / speciesMax); // The rate of emigration increases with the number of species habitatData [i].emigration = emigrationMax * (double)habitatData [i].speciesCount / speciesMax; // Probability of habitat existence if (habitatData [i].speciesCount <= speciesMax) { habitatData [i].probability = probabilities [habitatData [i].speciesCount]; } else { habitatData [i].probability = 0.0; } } } //——————————————————————————————————————————————————————————————————————————————
Die Migrationsmethode implementiert den Migrationsprozess (Austausch von SIV-Variablen – Variablen des Habitat-Eignungsindexes, d. h. Koordinatenwerten) zwischen Habitaten innerhalb einer Population. Der Methode liegt die Vorstellung zugrunde, dass Habitate mit hoher Einwanderungsrate (d. h. solche mit geringer Artenvielfalt) SIVs aus anderen Habitaten mit hoher Auswanderungsrate (d. h. solchen mit hoher Artenvielfalt) „aufnehmen“ können.
Die Schleife durchläuft alle Habitate der Population, überspringt jedoch die ersten elitismCount Habitate, die als „Elite“ gelten und von der Migration ausgenommen sind. Für jedes Habitat (mit Ausnahme der Elite-Habitate) wird zufällig festgelegt, ob es in der aktuellen Iteration verändert wird. Die Wahrscheinlichkeit einer Veränderung wird durch den Wert von „habitatData[i].immigration“ (die Einwanderungsrate des aktuellen Habitats) bestimmt. Wird ein Habitat für die Migration ausgewählt, durchläuft der Algorithmus alle seine Koordinaten (SIV). Für jede Koordinate wird erneut zufällig festgelegt, ob das Habitat geändert wird. Die Wahrscheinlichkeit einer Veränderung wird auch durch den Wert von „habitatData[i].immigration“ bestimmt.
Wird eine Koordinate zur Bearbeitung ausgewählt, wird das Habitat bestimmt, aus dem der Wert dieser Koordinate „entnommen“ wird. Diese Auswahl basiert auf einer Roulette-Selektion, die proportional zu den Werten von „habitatData[j].emigration“ (Abwanderungsraten anderer Habitate) ist. Das heißt, Habitate mit höheren Abwanderungsraten haben eine größere Chance, zu einer Migrationsquelle zu werden. Bei der Berechnung der Wahrscheinlichkeiten wird berücksichtigt, dass das aktuelle Habitat nicht als Quelle für sich selbst ausgewählt wird. Wenn eine Migrationsquelle ausgewählt wird, wird der Wert der entsprechenden Koordinate (SIV) vom Ausgangshabitat in das aktuelle Habitat kopiert.
Letztendlich führt das Verfahren einen regulierten Informationsaustausch (SIV) zwischen Habitaten durch, wobei Habitaten mit geringer Artenhäufigkeit (hohe Einwanderung) Informationen von Habitaten mit hoher Artenhäufigkeit (hohe Auswanderung) erhalten. Auf diese Weise können gute (SIV-)Lösungen in der Population verbreitet werden, während die besten Lösungen unverändert bleiben.
//+----------------------------------------------------------------------------+ //| Migration (exchange of SIVs between habitats) | //+----------------------------------------------------------------------------+ void C_AO_BBO::Migration () { for (int i = 0; i < popSize; i++) { // Skip elite solutions if (i < elitismCount) continue; // Determine whether the habitat will be modified if (u.RNDprobab () < habitatData [i].immigration) { // For each coordinate (SIV) for (int c = 0; c < coords; c++) { // Determine whether this coordinate will be modified if (u.RNDprobab () < habitatData [i].immigration) { // Select a migration source based on emigration rates double sumEmigration = 0.0; for (int j = 0; j < popSize; j++) { if (j != i) sumEmigration += habitatData [j].emigration; } if (sumEmigration > 0) { // Roulette source selection double roulette = u.RNDprobab () * sumEmigration; double cumSum = 0.0; for (int j = 0; j < popSize; j++) { if (j != i) { cumSum += habitatData [j].emigration; if (roulette <= cumSum) { // Copy SIV from habitat j to habitat i a [i].c [c] = a [j].c [c]; break; } } } } } } } } } //——————————————————————————————————————————————————————————————————————————————
Die Mutationsmethode verändert die Habitate innerhalb einer Population. Das Ziel der Mutation besteht darin, zufällige Änderungen an den Lösungen vorzunehmen, um zu vermeiden, dass man in lokalen Optima steckenbleibt, und um neuen Suchraum zu erkunden.
Wie bei der Migrationsmethode werden Elite-Lösungen (die ersten „elitismCount“-Habitate) übersprungen und nicht mutiert. Dies ist notwendig, um die gefundenen besten Lösungen zu speichern. Für jedes verbleibende Habitat wird die Mutationswahrscheinlichkeit berechnet. Es ist wichtig, dass die Mutationswahrscheinlichkeit umgekehrt proportional zur Existenzwahrscheinlichkeit des Habitats (habitatData [i].probability) ist. Das bedeutet, dass Habitate mit geringer Existenzwahrscheinlichkeit – darunter sowohl sehr schwache als auch sehr starke Extremlösungen – häufiger mutieren, um die Erkundung neuer Gebiete zu erleichtern.
Ist die erzeugte Zufallszahl kleiner als die berechnete Mutationsrate, findet eine Mutation statt. Aus allen „coords“ wird zufällig eine mutateCoord (SIV)-Koordinate für die Mutation ausgewählt. Für die ausgewählte Koordinate wird ein neuer Zufallswert innerhalb des angegebenen Bereichs generiert. Anschließend wird die Funktion SeInDiSp auf den neuen Wert angewendet, wodurch dieser auf die festgelegten Grenzwerte begrenzt wird.
Somit bringt die Mutationsmethode ein Element des Zufalls in den Suchprozess ein, wodurch der Algorithmus neue, potenziell bessere Lösungen finden kann, insbesondere in Bereichen, die noch nicht ausreichend erkundet wurden. Die Mutationsrate wird um die Wahrscheinlichkeit der Existenz eines Habitats bereinigt, um ein Gleichgewicht zwischen Exploration und Exploitation herzustellen (Exploration versus Exploitation).
//+----------------------------------------------------------------------------+ //| Probability-based mutation | //+----------------------------------------------------------------------------+ void C_AO_BBO::Mutation () { for (int i = 0; i < popSize; i++) { // Skip elite solutions if (i < elitismCount) continue; // The mutation rate is inversely proportional to the probability of existence double mutationRate = mutationProb * (1.0 - habitatData [i].probability); if (u.RNDprobab () < mutationRate) { // Select a random coordinate for mutation int mutateCoord = MathRand () % coords; // Generate a new value for the selected coordinate a [i].c [mutateCoord] = u.RNDfromCI (rangeMin [mutateCoord], rangeMax [mutateCoord]); a [i].c [mutateCoord] = u.SeInDiSp (a [i].c [mutateCoord], rangeMin [mutateCoord], rangeMax [mutateCoord], rangeStep [mutateCoord]); } } } //——————————————————————————————————————————————————————————————————————————————
Die Methode „CalculateProbability“ berechnet die Wahrscheinlichkeit, dass ein Habitat vorhanden ist, ausgehend von der Anzahl der Arten. Das Verfahren stützt sich auf ein vereinfachtes Modell: Die maximale Wahrscheinlichkeit wird in der Nähe des Gleichgewichtswerts der Art (in der Mitte des Verbreitungsgebiets) erreicht, und bei Abweichungen davon nimmt die Wahrscheinlichkeit entlang einer Gaußschen Kurve rapide ab. Je weiter speciesCount von speciesMax/2 entfernt ist, desto geringer ist die Wahrscheinlichkeit.
Insgesamt liefert die Methode ein Modell, in dem Habitate mit einer Artenzahl nahe am Gleichgewichtswert eine höhere Wahrscheinlichkeit aufweisen, zu existieren, als Habitate, deren Artenzahl stark vom Gleichgewichtswert abweicht. Dies stellt ein vereinfachtes, aber wirksames Modell für die „Eignung“ eines Habitats dar, das auf dessen biologischer Vielfalt basiert.
//+----------------------------------------------------------------------------+ //| Calculate the probability for a given number of species | //+----------------------------------------------------------------------------+ double C_AO_BBO::CalculateProbability (int speciesCount) { // Simplified probability model // Maximum probability in the middle of the range (equilibrium) int equilibrium = speciesMax / 2; double distance = MathAbs (speciesCount - equilibrium); double probability = MathExp (-distance * distance / (2.0 * equilibrium * equilibrium)); return probability; } //——————————————————————————————————————————————————————————————————————————————
Testergebnisse
Nachdem ich ein wenig mit den Parametern herumexperimentiert habe, habe ich festgestellt, dass der BBO-Algorithmus hervorragende Ergebnisse liefert.
BBO|Biogeography-Based Optimization|50.0|1.0|1.0|0.5|2.0|50.0|
=============================
5 Hilly's; Func runs: 10000; result: 0.9491244808033844
25 Hilly's; Func runs: 10000; result: 0.6945610309062928
500 Hilly's; Func runs: 10000; result: 0.35031241665471596
=============================
5 Forest's; Func runs: 10000; result: 0.9381951766964413
25 Forest's; Func runs: 10000; result: 0.6736501622157315
500 Forest's; Func runs: 10000; result: 0.2568167323109364
=============================
5 Megacity's; Func runs: 10000; result: 0.7461538461538464
25 Megacity's; Func runs: 10000; result: 0.4827692307692309
500 Megacity's; Func runs: 10000; result: 0.17369230769230892
=============================
All score: 5.26528 (58.50%)
Die Visualisierung zeigt, wie effizient der BBO-Algorithmus ist. Bei der schwierigsten diskreten Megacity-Funktion liefert der Algorithmus hervorragende Ergebnisse.
BBO mit der Funktion Hilly
BBO mit der Funktion Forest
BBO mit der Funktion Megacity
Aufgrund der Testergebnisse belegt der elegante BBO-Algorithmus den hervorragenden 12. Platz an der Spitze der Rangliste.
| # | 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 | Suche über die gesamte Nachbarschaft | 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-Algorithmus (joo) | 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 | AMOm | Optimierung der Tiermigration M | 0.90358 | 0.84317 | 0.46284 | 2.20959 | 0.99001 | 0.92436 | 0.46598 | 2.38034 | 0.56769 | 0.59132 | 0.23773 | 1.39675 | 5.987 | 66.52 |
| 4 | (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 |
| 5 | CTA | Kometenschweif-Algorithmus (joo) | 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 |
| 6 | TETA | Zeit-Evolutions-Reise-Algorithmus (Joo) | 0.91362 | 0.82349 | 0.31990 | 2.05701 | 0.97096 | 0.89532 | 0.29324 | 2.15952 | 0.73462 | 0.68569 | 0.16021 | 1.58052 | 5.797 | 64.41 |
| 7 | 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 |
| 8 | BOAm | Billard-Optimierungsalgorithmus M | 0.95757 | 0.82599 | 0.25235 | 2.03590 | 1.00000 | 0.90036 | 0.30502 | 2.20538 | 0.73538 | 0.52523 | 0.09563 | 1.35625 | 5.598 | 62.19 |
| 9 | AAm | Algorithmus für das Bogenschießen M | 0.91744 | 0.70876 | 0.42160 | 2.04780 | 0.92527 | 0.75802 | 0.35328 | 2.03657 | 0.67385 | 0.55200 | 0.23738 | 1.46323 | 5.548 | 61.64 |
| 10 | ESG | Entwicklung sozialer Gruppen (joo) | 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 |
| 11 | SIA | Simuliertes isotropes Glühen (Joo) | 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 |
| 12 | BBO | biogeografisch basierte Optimierung | 0.94912 | 0.69456 | 0.35031 | 1.99399 | 0.93820 | 0.67365 | 0.25682 | 1.86867 | 0.74615 | 0.48277 | 0.17369 | 1.40261 | 5.265 | 58.50 |
| 13 | 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 |
| 14 | DA | dialektischer Algorithmus | 0.86183 | 0.70033 | 0.33724 | 1.89940 | 0.98163 | 0.72772 | 0.28718 | 1.99653 | 0.70308 | 0.45292 | 0.16367 | 1.31967 | 5.216 | 57.95 |
| 15 | BHAm | Algorithmus für schwarze Löcher M | 0.75236 | 0.76675 | 0.34583 | 1.86493 | 0.93593 | 0.80152 | 0.27177 | 2.00923 | 0.65077 | 0.51646 | 0.15472 | 1.32195 | 5.196 | 57.73 |
| 16 | ASO | Anarchische Gesellschaftsoptimierung | 0.84872 | 0.74646 | 0.31465 | 1.90983 | 0.96148 | 0.79150 | 0.23803 | 1.99101 | 0.57077 | 0.54062 | 0.16614 | 1.27752 | 5.178 | 57.54 |
| 17 | RFO | Optimierung des Royal Flush (joo) | 0.83361 | 0.73742 | 0.34629 | 1.91733 | 0.89424 | 0.73824 | 0.24098 | 1.87346 | 0.63154 | 0.50292 | 0.16421 | 1.29867 | 5.089 | 56.55 |
| 18 | AOSm | Suche nach atomaren Orbitalen M | 0.80232 | 0.70449 | 0.31021 | 1.81702 | 0.85660 | 0.69451 | 0.21996 | 1.77107 | 0.74615 | 0.52862 | 0.14358 | 1.41835 | 5.006 | 55.63 |
| 19 | TSEA | Schildkrötenpanzer-Evolutionsalgorithmus (joo) | 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 |
| 20 | 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 |
| 21 | SRA | Algorithmus für erfolgreiche Gastronomen (joo) | 0.96883 | 0.63455 | 0.29217 | 1.89555 | 0.94637 | 0.55506 | 0.19124 | 1.69267 | 0.74923 | 0.44031 | 0.12526 | 1.31480 | 4.903 | 54.48 |
| 22 | 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 |
| 23 | BIO | Optimierung der Blutvererbung (joo) | 0.81568 | 0.65336 | 0.30877 | 1.77781 | 0.89937 | 0.65319 | 0.21760 | 1.77016 | 0.67846 | 0.47631 | 0.13902 | 1.29378 | 4.842 | 53.80 |
| 24 | 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 |
| 25 | 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 |
| 26 | 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 |
| 27 | BCOm | Optimierung mit der bakteriellen Chemotaxis M | 0.75953 | 0.62268 | 0.31483 | 1.69704 | 0.89378 | 0.61339 | 0.22542 | 1.73259 | 0.65385 | 0.42092 | 0.14435 | 1.21912 | 4.649 | 51.65 |
| 28 | ABO | Optimierung des afrikanischen Büffels | 0.83337 | 0.62247 | 0.29964 | 1.75548 | 0.92170 | 0.58618 | 0.19723 | 1.70511 | 0.61000 | 0.43154 | 0.13225 | 1.17378 | 4.634 | 51.49 |
| 29 | (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 |
| 30 | FBA | Fraktal-basierter Algorithmus | 0.79000 | 0.65134 | 0.28965 | 1.73099 | 0.87158 | 0.56823 | 0.18877 | 1.62858 | 0.61077 | 0.46062 | 0.12398 | 1.19537 | 4.555 | 50.61 |
| 31 | TSm | Tabu-Suche M | 0.87795 | 0.61431 | 0.29104 | 1.78330 | 0.92885 | 0.51844 | 0.19054 | 1.63783 | 0.61077 | 0.38215 | 0.12157 | 1.11449 | 4.536 | 50.40 |
| 32 | 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 |
| 33 | 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 |
| 34 | 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 |
| 35 | AEO | Algorithmus zur Optimierung auf der Grundlage künstlicher Ökosysteme | 0.91380 | 0.46713 | 0.26470 | 1.64563 | 0.90223 | 0.43705 | 0.21400 | 1.55327 | 0.66154 | 0.30800 | 0.28563 | 1.25517 | 4.454 | 49.49 |
| 36 | CAm | Kamel-Algorithmus M | 0.78684 | 0.56042 | 0.35133 | 1.69859 | 0.82772 | 0.56041 | 0.24336 | 1.63149 | 0.64846 | 0.33092 | 0.13418 | 1.11356 | 4.444 | 49.37 |
| 37 | 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 |
| 38 | 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 |
| 39 | SOA | einfacher Optimierungsalgorithmus | 0.91520 | 0.46976 | 0.27089 | 1.65585 | 0.89675 | 0.37401 | 0.16984 | 1.44060 | 0.69538 | 0.28031 | 0.10852 | 1.08422 | 4.181 | 46.45 |
| 40 | 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 |
| 41 | ACMO | Optimierung atmosphärischer Wolkenmodelle | 0.90321 | 0.48546 | 0.30403 | 1.69270 | 0.80268 | 0.37857 | 0.19178 | 1.37303 | 0.62308 | 0.24400 | 0.10795 | 0.97503 | 4.041 | 44.90 |
| 42 | ADAMm | adaptive Momentabschätzung M | 0.88635 | 0.44766 | 0.26613 | 1.60014 | 0.84497 | 0.38493 | 0.16889 | 1.39880 | 0.66154 | 0.27046 | 0.10594 | 1.03794 | 4.037 | 44.85 |
| 43 | CGO | Chaos Game Optimization | 0.57256 | 0.37158 | 0.32018 | 1.26432 | 0.61176 | 0.61931 | 0.62161 | 1.85267 | 0.37538 | 0.21923 | 0.19028 | 0.78490 | 3.902 | 43.35 |
| 44 | CROm | Korallenriff-Optimierung M | 0.78512 | 0.46032 | 0.25958 | 1.50502 | 0.86688 | 0.35297 | 0.16267 | 1.38252 | 0.63231 | 0.26738 | 0.10734 | 1.00703 | 3.895 | 43.27 |
| 45 | ATAm | Algorithmus für künstliche Stämme M | 0.71771 | 0.55304 | 0.25235 | 1.52310 | 0.82491 | 0.55904 | 0.20473 | 1.58867 | 0.44000 | 0.18615 | 0.09411 | 0.72026 | 3.832 | 42.58 |
| RW | Neuroboids Optimierungsalgorithmus 2(joo) | 0.48754 | 0.32159 | 0.25781 | 1.06694 | 0.37554 | 0.21944 | 0.15877 | 0.75375 | 0.27969 | 0.14917 | 0.09847 | 0.52734 | 2.348 | 26.09 | |
Zusammenfassung
Der BBO-Algorithmus (Biogeography-Based Optimization) erzielte in den Tests beeindruckende Ergebnisse und belegte mit einer Gesamtleistungsbewertung von 58,5 % den 12. Platz unter den 45 besten populationsbasierten Optimierungsalgorithmen. Das ist ein außergewöhnliches Ergebnis für einen Algorithmus, der auf einer so eleganten und intuitiven natürlichen Metapher basiert.
Besonders hervorzuheben ist die Fähigkeit von BBO, mittel- und hochdimensionale Probleme effizient zu lösen. Das unterstreicht seine Skalierbarkeit und Widerstandsfähigkeit gegenüber dem „Fluch der Dimension“ – einem Problem, mit dem viele Optimierungsalgorithmen zu kämpfen haben.
Die konzeptionelle Grundlage von BBO – die Migration von Arten zwischen Inseln – erwies sich nicht nur als schöne Metapher, sondern auch als äußerst effizienter Mechanismus zwischen Exploration des Suchraums und Exploitation der gefundenen Lösungen. Ein lineares Migrationsmodell, bei dem ressourcenreiche Habitate ihre Eigenschaften aktiv weitergeben und ärmere Habitate diese aktiv übernehmen, schafft einen natürlichen Gradienten des Informationsflusses von besseren zu schlechteren Lösungen.
Der BBO-Mutationsoperator verdient besondere Beachtung, da er sich grundlegend von klassischen Ansätzen unterscheidet. Anstelle einer festen oder zufälligen Mutationswahrscheinlichkeit verwendet BBO ein theoretisch fundiertes Modell, bei dem die Mutationswahrscheinlichkeit umgekehrt proportional zur Wahrscheinlichkeit der Existenz eines Habitats ist. Das bedeutet, dass die „natürlichsten“ und stabilsten Lösungen (mit einer durchschnittlichen Anzahl von Arten) selten mutieren, während extreme Lösungen – sowohl sehr gute als auch sehr schlechte – häufigeren Veränderungen unterliegen. Dieser Ansatz schafft einen adaptiven Mechanismus, der das Gleichgewicht zwischen Stabilität und Variabilität der Population automatisch reguliert.
Der Algorithmus zeigt eine hervorragende Stabilität über verschiedene Landschaftstypen hinweg: Er weist in allen Tests eine einheitlich grüne Färbung auf und zeigt im Vergleich zu anderen Optimierungsalgorithmen keinen nennenswerten Leistungsabfall.
Ein wichtiger Vorteil von BBO ist seine konzeptionelle Einfachheit in Verbindung mit hoher Effizienz. Im Gegensatz zu einigen modernen Metaheuristiken, die zahlreiche Parameter und komplexe Operatoren erfordern, arbeitet BBO mit intuitiven Konzepten: Migration, Anzahl der Arten, Eignung des Habitats.
Die Testergebnisse bestätigen, dass BBO nicht nur „ein weiterer“ bioinspirierter Algorithmus ist, sondern eine vollwertige und wettbewerbsfähige Optimierungsmethode, die es mit den anerkannten Spitzenreitern auf diesem Gebiet aufnehmen kann. Die Kombination aus theoretischer Fundiertheit, Recheneffizienz und praktischer Anwendbarkeit macht BBO zu einer wertvollen Ergänzung des Instrumentariums moderner globaler Optimierungsmethoden.
Abb. 2. Farbskala der Algorithmen nach den entsprechenden Tests
Abb. 3. Histogramm der Algorithmus-Testergebnisse (Skala von 0 bis 100, je höher, desto besser, wobei 100 das maximal mögliche theoretische Ergebnis ist; im Archiv befindet sich ein Skript zur Berechnung der Bewertungstabelle)
Vor- und Nachteile von BBO:
Vorteile:
- Schnell.
- Einfache Implementierung.
- Gute Ergebnisse über einen breiten Bereich von Problemdimensionen hinweg
Nachteile:
- Eine große Anzahl an Parametern.
Dem Artikel liegt ein Archiv mit den aktuellen Versionen der Algorithmuscodes bei. 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 Experimente.
Programme, die in diesem Artikel verwendet werden
| # | Name | Typ | Beschreibung |
|---|---|---|---|
| 1 | #C_AO.mqh | Include | Übergeordnete Klasse von Populationsoptimierungsalgorithmen |
| 2 | #C_AO_enum.mqh | Include | Enumeration der Algorithmen zur Populationsoptimierung |
| 3 | TestFunctions.mqh | Include | Bibliothek mit Testfunktionen |
| 4 | TestStandFunctions.mqh | Include | Bibliothek mit Funktionen für die Testumgebung |
| 5 | Utilities.mqh | Include | Bibliothek mit Hilfsfunktionen |
| 6 | CalculationTestResults.mqh | Include | Skript zur Berechnung der Ergebnisse in der Vergleichstabelle |
| 7 | Testing AOs.mq5 | Skript | Die einheitliche Testumgebung für alle Algorithmen zur Populationsoptimierung |
| 8 | Simple use of population optimization algorithms.mq5 | Skript | Ein einfaches Beispiel für die Verwendung von Algorithmen zur Populationsoptimierung ohne Visualisierung |
| 9 | Test_AO_BBO.mq5 | Skript | BBO-Testumgebung |
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/18354
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.
Analyse der Bilanzdaten von Zentralbanken zur Einschätzung der globalen Liquidität
CFTC-Datenanalyse in Python und Erstellung eines KI-Modells
Marktsimulation (Teil 24): Erste Schritte mit SQL (VII)
Marktsimulation (Teil 23): Erste Schritte mit SQL (VI)
- 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.