Algorithmen zur Optimierung mit Populationen Fledermaus-Algorithmus (BA)
Inhalt
1. Einführung
2. Beschreibung des Algorithmus
3. Testergebnisse
1. Einführung
Fledermäuse sind erstaunliche Tiere. Wissenschaftler glauben, dass die ersten Fledermäuse vor 65-100 Millionen Jahren auftauchten und Seite an Seite mit Dinosauriern lebten. Fledermäuse sind die einzigen geflügelten Säugetiere. Bei den Fledermäusen gibt es über 1300 Arten. Sie sind fast überall zu finden, außer in den Polarregionen. Tagsüber verstecken sie sich in Unterständen. Um sich in dunklen Höhlen zurechtzufinden und nach Einbruch der Dunkelheit zu jagen, nutzen Fledermäuse die Echoortung, ein System, mit dem sie Objekte anhand von Schallwellen erkennen können. Ihre Echoortung sendet einen hochfrequenten Ton aus, der sich vorwärts bewegt, bis er auf ein Objekt trifft und zurückgeworfen wird. Die Echoortung ist eine Art Sonar: Eine Fledermaus sendet einen lauten und kurzen gepulsten Ton aus. Wenn der Schall ein Objekt erreicht, kehrt das Echo nach kurzer Zeit zu den Ohren der Fledermaus zurück. Auf diese Weise orientieren sich die Fledermäuse im Raum und bestimmen die Position ihrer Beute.
Der Fledermausalgorithmus (BA) ist ein heuristischer Algorithmus, der 2010 von Yang eingeführt wurde und das Echoortungsverhalten von Fledermäusen nachahmt, um eine globale Optimierung durchzuführen. Metaheuristiken, die in der Regel von der Natur und physikalischen Prozessen inspiriert sind, werden heute als eine der leistungsfähigsten Techniken für die Lösung vieler komplexer Optimierungsprobleme eingesetzt. Optimierung ist die Auswahl der besten Elemente für einen bestimmten Satz von Kriterien aus einer Reihe von effizienten Optionen, die viele verschiedene Vor- und Nachteile in Bezug auf die Berechnungseffizienz und die Wahrscheinlichkeit einer globalen Optimierung aufweist.
Die Merkmalsoptimierung bietet einen formalen Rahmen für die Modellierung und Lösung einer Reihe spezifischer Probleme, indem sie eine „Zielfunktion“ bereitstellt, die einen Parameter als Eingabe annimmt. Ziel ist es, den Wert des kombinierten Parameters zu finden, der den besten Wert ergibt. Dieser Rahmen ist so abstrakt, dass verschiedene Probleme als „Merkmalsoptimierungsprobleme“ interpretiert werden können.
Die herkömmliche Merkmalsoptimierung wird jedoch nur zur Lösung einiger kleiner Probleme verwendet, die in der Praxis oft nicht anwendbar sind. Daher wenden sich die Wissenschaftler der Natur zu, die reichhaltige Modelle für die Lösung dieser Probleme bietet. Durch die Modellierung natürlicher biologischer Systeme werden viele intelligente Schwarmoptimierungsalgorithmen vorgeschlagen, um angewandte Probleme mit unkonventionellen Methoden zu lösen. Aufgrund ihrer hervorragenden Leistung werden sie häufig bei verschiedenen Optimierungsproblemen eingesetzt. BA ist ein neuer und moderner schwarmähnlicher Algorithmus, der einen Suchprozess mit künstlichen Fledermäusen als Suchagenten durchführt, die die natürliche Lautstärke und Emissionsfrequenz von echten Fledermäusen simulieren.
2. Beschreibung des Algorithmus
Im grundlegenden Fledermaus-Algorithmus wird jede Fledermaus als „masseloses und größenloses“ Teilchen behandelt, das eine gültige Lösung im Lösungsraum darstellt. Für verschiedene Fitnessfunktionen hat jede Fledermaus einen entsprechenden Merkmalswert und ermittelt durch den Vergleich der Merkmalswerte das aktuell optimale Individuum. Dann werden die Frequenz der akustischen Welle, die Geschwindigkeit, die Geschwindigkeit der Impulsabgabe und das Volumen jeder Fledermaus in der Population aktualisiert, die iterative Evolution wird fortgesetzt, die aktuelle optimale Lösung wird angenähert und erzeugt, und schließlich wird die globale optimale Lösung gefunden. Der Algorithmus aktualisiert die Frequenz, die Geschwindigkeit und die Position jeder einzelnen Fledermaus.
Der Standardalgorithmus erfordert fünf grundlegende Parameter: Frequenz, Lautstärke, Welligkeit sowie das Verhältnis von Lautheit und Welligkeit. Die Häufigkeit wird verwendet, um die Auswirkungen der historisch besten Position auf die aktuelle Position auszugleichen. Eine einzelne Fledermaus wird weit von der historischen Position der Gruppe entfernt suchen, wenn der Suchfrequenzbereich groß ist, und umgekehrt.
Der Algorithmus umfasst eine ganze Reihe von Parametern im Vergleich zu den zuvor betrachteten:
input double MIN_FREQ_P = 0.0;
input double MAX_FREQ_P = 1.0;
input double MIN_LOUDNESS_P = 0.0;
input double MAX_LOUDNESS_P = 1.5;
input double MIN_PULSE_P = 0.0;
input double MAX_PULSE_P = 1.0;
input double ALPHA_P = 0.3;
input double GAMMA_P = 0.3;
Bei der Implementierung des BA-Algorithmus bin ich darauf gestoßen, dass in vielen Quellen die Autoren der Artikel den Algorithmus auf völlig unterschiedliche Weise beschreiben. Die Unterschiede liegen sowohl in der Verwendung von Begriffen bei der Beschreibung von Schlüsselpunkten als auch in den grundlegenden algorithmischen Merkmalen, daher werde ich beschreiben, wie ich es selbst verstanden habe. Die grundlegenden physikalischen Prinzipien, die der Echoortung zugrunde liegen, können in dem Algorithmus mit erheblichen Vorbehalten und Konventionen angewendet werden. Wir nehmen an, dass die Fledermäuse Schallimpulse mit einer Frequenz zwischen MinFreq und MaxFreq verwenden. Die Frequenz wirkt sich auf die Schnelligkeit der Fledermaus aus. Es wird auch das Konzept der bedingten Lautheit verwendet, das den Übergang vom Zustand der lokalen Suche am Ort der aktuellen Position der Fledermaus zum globalen Zustand in der Nähe der besten Lösung beeinflusst. Während der Optimierung nimmt die Pulsationsfrequenz zu, während die Lautstärke der Töne abnimmt.
Pseudocode des BA-Algorithmus (Abb. 1):
1. Initialisierung der Fledermauspopulation.
2. Generierung von Frequenz, Geschwindigkeit und neuen Lösungen.
3. Suche nach einer lokalen Lösung.
4. Aktualisierung der globalen Lösung.
5. Verringern der Lautstärke und Erhöhen der Pulsationsfrequenz.
6. Wiederholen Sie Schritt 2, bis das Stoppkriterium erfüllt ist.
Abb. 1. Blockdiagramm des BA-Algorithmus
Beginnen wir mit der Beschreibung des Codes. Um den „Fledermaus“-Suchagenten zu beschreiben, benötigen wir eine Struktur, in der wir alle Merkmale beschreiben, die für eine vollständige Beschreibung des Zustands zum Zeitpunkt jeder Iteration erforderlich sind. Das Array position[] wird verwendet, um die besten Positionskoordinaten im Raum zu speichern, während das Array auxPosition[] die aktuellen „operativen“ Koordinaten enthält. Das Array speed[] wird für die Berechnung des Geschwindigkeitsvektors nach Koordinaten benötigt. frequency - Frequenz der Schallimpulse, initPulseRate - anfängliche Impulsrate (individuell für jede Fledermaus von Beginn der Optimierung an), pulseRate - Impulsrate in der aktuellen Iteration, loudness - Lautstärke der Schallimpulse, fitness - Wert der Fitnessfunktion nach dem letzten Zug, fitnessBest - bester Wert der Fitnessfunktion des Agenten für alle Iterationen.
//—————————————————————————————————————————————————————————————————————————————— struct S_Bat { double position []; double auxPosition []; double speed []; double frequency; double initPulseRate; double pulseRate; double loudness; double fitness; double fitnessBest; }; //——————————————————————————————————————————————————————————————————————————————
Die Klasse des Fledermausalgorithmus‘ enthält ein Array von Strukturen der Suchagenten, Grenzen und Schritt des untersuchten Raums, die besten vom Algorithmus gefundenen Koordinaten, den besten Wert der Fitnessfunktion und Konstanten zur Speicherung von Algorithmusparametern, sowie die öffentliche Initialisierungsmethode, zwei öffentliche Methoden, die für die Arbeit mit dem Algorithmus erforderlich sind, und algorithmusspezifische private Methoden.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_BA { //============================================================================ public: S_Bat bats []; //bats public: double rangeMax []; //maximum search range public: double rangeMin []; //manimum search range public: double rangeStep []; //step search public: double cB []; //best coordinates public: double fB; //FF of the best coordinates public: void Init (const int paramsP, const int batsNumberP, const double min_FREQ_P, const double max_FREQ_P, const double min_LOUDNESS_P, const double max_LOUDNESS_P, const double min_PULSE_P, const double max_PULSE_P, const double alpha_P, const double gamma_P, const int maxIterP); public: void Flight (int epoch); public: void Preparation (); //============================================================================ private: void Walk (S_Bat &bat); private: void AproxBest (S_Bat &bat, double averageLoudness); private: void AcceptNewSolutions (S_Bat &bat); private: int currentIteration; private: int maxIter; private: double MIN_FREQ; private: double MAX_FREQ; private: double MIN_LOUDNESS; private: double MAX_LOUDNESS; private: double MIN_PULSE; private: double MAX_PULSE; private: double ALPHA; private: double GAMMA; private: int params; private: int batsNumber; private: bool firstFlight; private: double SeInDiSp (double In, double inMin, double inMax, double step); private: double RNDfromCI (double min, double max); private: double Scale (double In, double InMIN, double InMAX, double OutMIN, double OutMAX, bool revers); }; //——————————————————————————————————————————————————————————————————————————————
In der öffentlichen Methode Init() des Algorithmus werden die Parameter eingestellt, der Speicher für die Arrays zugewiesen, die Variable auf den Mindestwert zurückgesetzt, um die beste Anpassung zu speichern, und das Flag der ersten Iteration zurückgesetzt. Im Allgemeinen ist diese Methode nicht kompliziert und etwas Besonderes.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_BA::Init (const int paramsP, const int batsNumberP, const double min_FREQ_P, const double max_FREQ_P, const double min_LOUDNESS_P, const double max_LOUDNESS_P, const double min_PULSE_P, const double max_PULSE_P, const double alpha_P, const double gamma_P, const int maxIterP) { MathSrand (GetTickCount ()); fB = -DBL_MAX; params = paramsP; batsNumber = batsNumberP; MIN_FREQ = min_FREQ_P; MAX_FREQ = max_FREQ_P; MIN_LOUDNESS = min_LOUDNESS_P; MAX_LOUDNESS = max_LOUDNESS_P; MIN_PULSE = min_PULSE_P; MAX_PULSE = max_PULSE_P; ALPHA = alpha_P; GAMMA = gamma_P; maxIter = maxIterP; ArrayResize (rangeMax, params); ArrayResize (rangeMin, params); ArrayResize (rangeStep, params); firstFlight = false; ArrayResize (bats, batsNumber); for (int i = 0; i < batsNumber; i++) { ArrayResize (bats [i].position, params); ArrayResize (bats [i].auxPosition, params); ArrayResize (bats [i].speed, params); bats [i].fitness = -DBL_MAX; } ArrayResize (cB, params); } //——————————————————————————————————————————————————————————————————————————————
Die erste Methode, die bei jeder Iteration aufgerufen wird, ist Flight(). Sie konzentriert sich auf den Hauptrahmen der Suchlogik, und der Rest der Details ist in privaten Hilfsmethoden untergebracht, die für diesen Optimierungsalgorithmus spezifisch sind. Bei der allerersten Iteration wird das Flag firstFlight zurückgesetzt (das Zurücksetzen erfolgt während der Initialisierung in der Methode Init()), was bedeutet, dass wir jeder Fledermaus einen Anfangszustand zuweisen müssen, der eine zufällige Position im Suchraum ist:
- Geschwindigkeit Null,
- individuelle Frequenz der Schallimpulse, die durch eine Zufallszahl in dem durch die Parameter festgelegten Bereich bestimmt wird,
- anfängliche individuelle Pulsationsfrequenz, die ebenfalls durch eine Zufallszahl im Parameterbereich festgelegt wird
- und die Lautstärke der Schallimpulse im Parameterbereich.
Wie Sie sehen können, hat jede künstliche Fledermaus eine individuelle Reihe von Merkmalen von Schallsignalen, die sie echten Fledermäusen in der Natur ähnlicher machen. In der gesamten Population, die aus mehreren Hunderttausend Individuen bestehen kann, kann eine Mutter ein einziges Jungtier anhand der einzigartigen Geräuschsignatur finden, die das Baby aussendet.
Wenn das Flag firstFlight aktiviert ist, müssen grundlegende Operationen durchgeführt werden, um Fledermäuse zu bewegen. Eine der interessanten Eigenschaften des Algorithmus liegt in dem Konzept der durchschnittlichen Lautstärke der gesamten Population. Im Allgemeinen nimmt die Lautstärke über den Koeffizienten „alpha“ in allen Iterationen ab. Hier gibt es zwei Arten von Fledermausbewegungen: Walk() - individuelle Bewegung mit Berechnung des Geschwindigkeitsvektors für jede Koordinatenkomponente und lokale Bewegung in der Nähe der besten Lösung.
Mit jeder weiteren Iteration nimmt die Intensität der Pulsationen ab, was sich auf die Intensität der Nachbarschaftserkundung auswirkt. Daher ändern sich Erkundung und Nutzung während der Optimierung dynamisch. Als Nächstes werden wir sehen, wie die aktuelle Iteration das Verhalten der Fledermäuse beeinflusst.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_BA::Flight (int epoch) { currentIteration = epoch; //============================================================================ if (!firstFlight) { fB = -DBL_MAX; //-------------------------------------------------------------------------- for (int b = 0; b < batsNumber; b++) { for (int p = 0; p < params; p++) { bats [b].position [p] = RNDfromCI (rangeMin [p], rangeMax [p]); bats [b].position [p] = SeInDiSp (bats [b].position [p], rangeMin [p], rangeMax [p], rangeStep [p]); bats [b].auxPosition [p] = bats [b].position [p]; bats [b].speed [p] = 0.0; bats [b].frequency = RNDfromCI (MIN_FREQ, MAX_FREQ); bats [b].initPulseRate = RNDfromCI (MIN_PULSE, MAX_PULSE / 2); bats [b].pulseRate = bats [b].initPulseRate; bats [b].loudness = RNDfromCI (MAX_LOUDNESS / 2, MAX_LOUDNESS); bats [b].fitness = -DBL_MAX; bats [b].fitnessBest = -DBL_MAX; } } firstFlight = true; } //============================================================================ else { double avgLoudness = 0; for (int b = 0; b < batsNumber; b++) { avgLoudness += bats [b].loudness; } avgLoudness /= batsNumber; for (int b = 0; b < batsNumber; b++) { Walk (bats [b]); if (RNDfromCI (MIN_PULSE, MAX_PULSE) > bats [b].pulseRate) { AproxBest (bats [b], avgLoudness); } } } } //——————————————————————————————————————————————————————————————————————————————
Die zweite erforderliche öffentliche Methode, die bei jeder Iteration aufgerufen wird - Preparation() - wird benötigt, um die global beste Lösung zu aktualisieren. Hier können wir sehen, wie das Konzept der „Lautstärke“ verwendet wird. Da mit jeder Iteration das Volumen jeder Maus um einen Faktor („alpha“-Algorithmusabstimmungsparameter) abnimmt, sinkt die Wahrscheinlichkeit einer lokalen Studie zusammen mit der Intensität der globalen Lösungsstudie. Mit anderen Worten: Die Wahrscheinlichkeit, dass die beste Position jeder Fledermaus aktualisiert wird, nimmt mit jeder Iteration ab. Dies ist einer der Momente im Algorithmus, der am wenigsten verstanden wird, zumindest für mich. Der Autor des Algorithmus hat dies jedoch implementiert, was bedeutet, dass es notwendig ist.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_BA::Preparation () { //---------------------------------------------------------------------------- for (int b = 0; b < batsNumber; b++) { if (bats [b].fitness > fB) { fB = bats [b].fitness; ArrayCopy (cB, bats [b].auxPosition, 0, 0, WHOLE_ARRAY); } } //---------------------------------------------------------------------------- for (int b = 0; b < batsNumber; b++) { if (RNDfromCI (MIN_LOUDNESS, MAX_LOUDNESS) < bats [b].loudness && bats [b].fitness >= bats [b].fitnessBest) { AcceptNewSolutions (bats [b]); } } } //——————————————————————————————————————————————————————————————————————————————
Die private Methode Walk() sorgt dafür, dass sich jede Fledermaus einzeln in Bezug auf ihre bisher beste Position bewegt, wenn die global beste Lösung vorliegt. Bei dieser Methode wird die Frequenz der Schallimpulse verwendet, die innerhalb des Bereichs [MIN_FREQ;MAX_FREQ] zufällig variiert. Die Frequenz wird benötigt, um die Bewegungsgeschwindigkeit des Suchagenten zu berechnen, die das Produkt aus der Frequenz und der Differenz zwischen der besten Mausposition und der besten globalen Lösung ist. Danach wird der Geschwindigkeitswert der aktuell besten Lösung des Fledermausvektors vektorweise hinzugefügt. Wir arbeiten also mit unverhältnismäßig großen physikalischen Größen, aber was können wir tun? Dies ist nur eine Annäherung an reale physische Objekte. Die Plausibilität ist in diesem Fall zu vernachlässigen. Nach der Berechnung der neuen Position sollten die Koordinaten mit der Methode SeInDiSp() auf Bereichsüberschreitungen überprüft werden.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_BA::Walk (S_Bat &bat) { for (int j = 0; j < params; ++j) { bat.frequency = MIN_FREQ + (MAX_FREQ - MIN_FREQ) * RNDfromCI (0.0, 1.0); bat.speed [j] = bat.speed [j] + (bat.position [j] - cB [j]) * bat.frequency; bat.auxPosition [j] = bat.position [j] + bat.speed [j]; bat.auxPosition [j] = SeInDiSp (bat.auxPosition [j], rangeMin [j], rangeMax [j], rangeStep [j]); } } //——————————————————————————————————————————————————————————————————————————————
Die zweite, private Methode, AproxBest(), ist dafür verantwortlich, die Fledermäuse relativ zur besten globalen Lösung zu verschieben und so eine zusätzliche Koordinatenverfeinerung zu erreichen. Es ist mir nicht möglich, die physikalische Bedeutung dieses Vorgangs zu verstehen, der darin besteht, dass die Koordinaten des Inkrements in Form der durchschnittlichen Lautstärke der gesamten Fledermauspopulation, multipliziert mit einer Zufallszahl im Bereich [-1,0; 1,0], Vektor für Vektor addiert werden. Ich habe versucht, die Werte auf die Dimension der zu optimierenden Funktion durch den Vektor der gültigen Werte des Definitionsbereichs zu reduzieren, aber die Testergebnisse erwiesen sich als schlechter als in der Version des Autors des Algorithmus, sodass ich alles so gelassen habe, wie es ist, aber ich bin sicher, dass die Effizienz des BA-Algorithmus verbessert werden kann, aber dies wird zusätzliche Forschung erfordern, was in diesem Fall nicht das Ziel war. Nach der Berechnung der Koordinaten werden die Werte mit der Methode SeInDiSp() auf Bereichsüberschreitungen überprüft.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_BA::AproxBest (S_Bat &bat, double averageLoudness) { for (int j = 0; j < params; ++j) { bat.auxPosition [j] = cB [j] + averageLoudness * RNDfromCI (-1.0, 1.0); bat.auxPosition [j] = SeInDiSp (bat.auxPosition [j], rangeMin [j], rangeMax [j], rangeStep [j]); } } //——————————————————————————————————————————————————————————————————————————————
Eine weitere spezifische private Methode ist AcceptNewSolutions(), die aufgerufen wird, wenn die Testbedingung für die Frequenz der Schallimpulse für jede Fledermaus erfüllt ist. Die neue beste individuelle Lösung wird akzeptiert, sowie die individuelle Lautheit und die individuelle Pulsfrequenz werden hier neu berechnet. Hier sehen wir, wie die Ordnungszahl einer Iteration in die Berechnung der Pulsationsfrequenz einfließt.
An dieser Stelle in der Logik des Algorithmus habe ich mir einige Freiheiten genommen und die Logik geändert, indem ich das Ergebnis von der Dimension der Gesamtzahl der Iterationen unabhängig gemacht habe, was letztendlich die Effizienz des Algorithmus leicht erhöht hat. In der ursprünglichen Version wurde die Iterationszahl direkt in die nichtlineare Formel zur Berechnung der Pulsfrequenz einbezogen. In der BA gibt es bereits eine Vielzahl von Konventionen. In diesem Fall konnte ich meine Augen nicht vor einer Weiteren verschließen.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_BA::AcceptNewSolutions (S_Bat &bat) { ArrayCopy(bat.position, bat.auxPosition, 0, 0, WHOLE_ARRAY); bat.fitnessBest = bat.fitness; bat.loudness = ALPHA * bat.loudness; double iter = Scale (currentIteration, 1, maxIter, 0.0, 10.0, false); bat.pulseRate = bat.initPulseRate *(1.0 - exp(-GAMMA * iter)); } //——————————————————————————————————————————————————————————————————————————————
Die Abhängigkeit der Pulsationsfrequenz von der Nummer der aktuellen Iteration (x im Diagramm) und dem GAMMA-Einstellungsparameter ist in Abbildung 2 dargestellt.
Abb. 2. Abhängigkeit der Pulsationsfrequenz von der Nummer der aktuellen Iteration und dem Einstellparameter GAMMA mit den Werten 0,9, 0,7, 0,5, 0,3, 0,2
3. Testergebnisse
Im letzten Artikel erwähnte ich, dass die Methodik zur Berechnung der Bewertung der getesteten Algorithmen überarbeitet werden soll. Erstens: Da die meisten Algorithmen problemlos mit Testfunktionen mit zwei Variablen umgehen können und der Unterschied zwischen den Ergebnissen fast ununterscheidbar ist, habe ich beschlossen, die Anzahl der Variablen für die ersten beiden Tests für alle Testfunktionen zu erhöhen. Die Anzahl der Variablen wird nun 10, 50 und 1000 sein.
Zweitens wurde die Testfunktion Skin durch die weit verbreitete Rastrigin-Funktion ersetzt (Abbildung 3). Diese Funktion ist glatt wie Skin. Es handelt sich um eine komplexe Oberfläche mit vielen lokalen Extrema, einem globalen Maximum an vier Punkten und einem globalen Minimum in der Mitte der Koordinatenachsen.
Drittens habe ich beschlossen, die Testergebnisse auf einen Wertebereich zwischen allen Algorithmen in der Tabelle zu normalisieren, wobei das beste Ergebnis 1,0 und das schlechteste Ergebnis 0,0 ist. Dies ermöglicht eine gleichmäßige Auswertung der Testergebnisse, wobei die Komplexität der Funktionen entsprechend den Ergebnissen der einzelnen Optimierungsalgorithmen im Test berücksichtigt wird.
Anschließend werden die Ergebnisse der Prüfung der Algorithmen zusammenfassend dargestellt. Das maximale Ergebnis erhält den Wert 100 (maximales Referenzergebnis), während der Mindestwert 1 beträgt. So können wir die Algorithmen direkt miteinander vergleichen, ohne die Komplexität der Testfunktionen zu berücksichtigen. Jetzt werden die mit Print() ausgedruckten Ergebnisse in den Quelldateien der Testskripte für jeden Algorithmus gespeichert. Das Skript, mit dem die Punktzahlen in den Tests berechnet werden, ist unten angefügt. Sie wird in späteren Artikeln um die Ergebnisse der neuen Algorithmen ergänzt.
Abb. 3. Rastrigin-Testfunktion
Die Ergebnisse des Testverfahrens sehen wie folgt aus:
2022.12.28 17:13:46.384 Test_AO_BA (EURUSD,M1) C_AO_BA:50;0.0;1.0;0.0;1.5;0.0;1.0;0.3;0.3 2022.12.28 17:13:46.384 Test_AO_BA (EURUSD,M1) ============================= 2022.12.28 17:13:48.451 Test_AO_BA (EURUSD,M1) 5 Rastrigin's; Func runs 10000 result: 66.63334336098077 2022.12.28 17:13:48.451 Test_AO_BA (EURUSD,M1) Score: 0.82562 2022.12.28 17:13:52.630 Test_AO_BA (EURUSD,M1) 25 Rastrigin's; Func runs 10000 result: 65.51391114042588 2022.12.28 17:13:52.630 Test_AO_BA (EURUSD,M1) Score: 0.81175 2022.12.28 17:14:27.234 Test_AO_BA (EURUSD,M1) 500 Rastrigin's; Func runs 10000 result: 59.84512760590815 2022.12.28 17:14:27.234 Test_AO_BA (EURUSD,M1) Score: 0.74151 2022.12.28 17:14:27.234 Test_AO_BA (EURUSD,M1) ============================= 2022.12.28 17:14:32.280 Test_AO_BA (EURUSD,M1) 5 Forest's; Func runs 10000 result: 0.5861602092218606 2022.12.28 17:14:32.280 Test_AO_BA (EURUSD,M1) Score: 0.33156 2022.12.28 17:14:39.204 Test_AO_BA (EURUSD,M1) 25 Forest's; Func runs 10000 result: 0.2895682720055589 2022.12.28 17:14:39.204 Test_AO_BA (EURUSD,M1) Score: 0.16379 2022.12.28 17:15:14.716 Test_AO_BA (EURUSD,M1) 500 Forest's; Func runs 10000 result: 0.09867854051596259 2022.12.28 17:15:14.716 Test_AO_BA (EURUSD,M1) Score: 0.05582 2022.12.28 17:15:14.716 Test_AO_BA (EURUSD,M1) ============================= 2022.12.28 17:15:20.843 Test_AO_BA (EURUSD,M1) 5 Megacity's; Func runs 10000 result: 3.3199999999999994 2022.12.28 17:15:20.843 Test_AO_BA (EURUSD,M1) Score: 0.27667 2022.12.28 17:15:26.624 Test_AO_BA (EURUSD,M1) 25 Megacity's; Func runs 10000 result: 1.2079999999999997 2022.12.28 17:15:26.624 Test_AO_BA (EURUSD,M1) Score: 0.10067 2022.12.28 17:16:05.013 Test_AO_BA (EURUSD,M1) 500 Megacity's; Func runs 10000 result: 0.40759999999999996 2022.12.28 17:16:05.013 Test_AO_BA (EURUSD,M1) Score: 0.03397
Der Fledermaus-Algorithmus hat beeindruckende Ergebnisse bei der glatten Rastrigin-Funktion gezeigt. Interessanterweise steigt die Stabilität (Wiederholbarkeit) der Ergebnisse mit zunehmender Anzahl der Variablen in der Funktion, was auf eine ausgezeichnete Skalierbarkeit der BA bei glatten Funktionen hindeutet. Insbesondere erwies sich BA bei der Rastrigin-Funktion mit 50 und 1000 Variablen unter allen Testteilnehmern als am besten, was uns erlaubt, den Fledermaus-Algorithmus für die Arbeit mit komplexen glatten Funktionen und neuronalen Netzen zu empfehlen. Bei den Funktionen Wald und Megastadt zeigte der Fledermausalgorithmus durchschnittliche Ergebnisse, die eine Tendenz zum Verharren in lokalen Extremen erkennen lassen. Die Koordinaten sind in Gruppen lokalisiert und zeigen nicht die Dynamik der Veränderung und der Bewegung in Richtung des globalen Optimums. Ich denke, das liegt daran, dass der Algorithmus empfindlich auf das Vorhandensein eines Gradienten auf der Oberfläche der untersuchten Funktion reagiert. In Abwesenheit des Gradienten hält der Algorithmus schnell in der Nähe von lokalen Bereichen an, die keinen signifikanten Anstieg der Werte der Fitnessfunktion aufweisen. Darüber hinaus fehlt dem BA-Algorithmus ein Mechanismus, der das „Springen“ in neue unbekannte Gebiete ermöglicht, ähnlich dem in COA implementierten Mechanismus (Levy-Flüge).
Ich sollte auch die große Anzahl von Einstellungen für BA erwähnen. Es gibt nicht nur viele Parameter (Freiheitsgrade), sondern jeder von ihnen hat einen großen Einfluss sowohl auf die Art der Sucheigenschaften als auch auf die Gesamtkonvergenzraten. Mit einigen Parametern lassen sich hervorragende Ergebnisse für glatte Funktionen erzielen, mit anderen für diskrete und zerklüftete Funktionen. Es ist eine schwierige Aufgabe, einige universelle Parameter zu finden, die es ermöglichen, mit verschiedenen Arten von Testfunktionen gleichermaßen gut zurechtzukommen. Der Artikel enthält den Quellcode des Fledermaus-Algorithmus mit den Parametern, die mir am optimalsten erscheinen. Im Allgemeinen würde ich Nutzern, die wenig Erfahrung im Umgang mit Optimierungsalgorithmen haben, nicht empfehlen, BA zu verwenden, da die Optimierungsergebnisse stark variieren können.
BA mit der Rastrigin-Testfunktion
BA mit dem Forest-Testfunktion
BA mit der Megacity-Testfunktion
Wenn man sich auf die Visualisierung der Testfunktionen konzentriert, kann man sich ein Bild von den charakteristischen Merkmalen des Fledermaus-Algorithmus machen. Insbesondere bei der Bearbeitung aller Testfunktionen zeichnet sich der Algorithmus dadurch aus, dass er Koordinaten in sehr kleinen lokalen Bereichen gruppiert. Während diese Eigenschaft bei einer glatten Funktion es ermöglicht, sich auch dort zu bewegen, wo sich der Gradient der Fitnessfunktion leicht ändert, erweist sich diese Eigenschaft bei einer diskreten Funktion als Nachteil, da der Algorithmus auf flachen Plateaus stecken bleibt.
Ergebnisse, die das Skript zur Berechnung der Ergebnisse der Optimierungsalgorithmen erzielt:
2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_RND======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.18210 | 0.15281 | 0.07011 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.08623 | 0.04810 | 0.06094 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.00000 | 0.00000 | 0.08904 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.6893397068905002 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_PSO======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.22131 | 0.12861 | 0.05966 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.15345 | 0.10486 | 0.28099 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.08028 | 0.02385 | 0.00000 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 1.053004072893302 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_ACOm======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.37458 | 0.28208 | 0.17991 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 1.00000 | 1.00000 | 1.00000 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 1.00000 | 1.00000 | 0.10959 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 5.946151922377553 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_ABC======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.84599 | 0.51308 | 0.22588 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.58850 | 0.21455 | 0.17249 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.47444 | 0.26681 | 0.35941 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 3.661160435265267 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_GWO======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.00000 | 0.00000 | 0.00000 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.00000 | 0.00000 | 0.00000 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.18977 | 0.04119 | 0.01802 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.24898721240154956 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_COAm======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 1.00000 | 0.73390 | 0.28892 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.64504 | 0.34034 | 0.21362 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.67153 | 0.34273 | 0.45422 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 4.690306586791184 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_FSS======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.50663 | 0.39737 | 0.11006 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.07806 | 0.05013 | 0.08423 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.00000 | 0.01084 | 0.18998 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 1.4272897567648186 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_FAm======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.64746 | 0.53292 | 0.18102 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.55408 | 0.42299 | 0.64360 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.21167 | 0.28416 | 1.00000 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 4.477897116029613 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) =======C_AO_BA======= 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.43859 | 1.00000 | 1.00000 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.17768 | 0.17477 | 0.33595 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.15329 | 0.07158 | 0.46287 | 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 3.8147314003892507 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) ================ 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) ================ 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) ================ 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) 0.24898721240154956 | 5.946151922377553 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_RND: 8.652 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_PSO: 14.971 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_ACOm: 100.000 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_ABC: 60.294 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_GWO: 1.000 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_COAm: 78.177 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_FSS: 21.475 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_FAm: 74.486 2023.01.03 17:55:57.386 CalculationTestResults (EURUSD,M1) C_AO_BA: 62.962
Werfen wir einen Blick auf die endgültige Bewertungstabelle. Wie bereits erwähnt, hat sich die Methode zur Berechnung der geschätzten Merkmale von Algorithmen geändert, sodass die Algorithmen eine neue Position eingenommen haben. Einige klassische Algorithmen wurden aus der Tabelle gestrichen, sodass nur noch ihre modifizierten Versionen übrig sind, die in Tests eine höhere Leistung aufweisen. Jetzt sind die Testergebnisse nicht mehr absolut (absolute normalisierte Ergebnisse der Testfunktionswerte), sondern relativ, basierend auf den Ergebnissen des Vergleichs der Algorithmen untereinander.
Die Tabelle zeigt, dass ACOm (Ameisenkolonieoptimierung) derzeit führend ist. Der Algorithmus hat in fünf von neun Tests die besten Ergebnisse erzielt, sodass das Endergebnis 100 Punkte beträgt. COAm, eine modifizierte Version des Kuckuck-Optimierungsalgorithmus, steht an zweiter Stelle. Dieser Algorithmus erwies sich als der beste bei der glatten Rastrigin-Funktion und zeigte auch bei anderen Tests gute Ergebnisse im Vergleich zu anderen Testteilnehmern. Der modifizierte Firefly-Algorithmus FAm hat den dritten Platz belegt. Sie hat die besten Ergebnisse bei der diskreten Funktion Megacity gezeigt. Nur der FSS zeigte bei diesem Test das gleiche Ergebnis.
AO | Beschreibung | Rastrigin | Rastrigin final | Forest | Forest final | Megacity (diskret) | Megacity final | Endergebnis | ||||||
10 Parameter (5 F) | 50 Parameter (25 F) | 1000 Parameter (500 F) | 10 Parameter (5 F) | 50 Parameter (25 F) | 1000 Parameter (500 F) | 10 Parameter (5 F) | 50 Parameter (25 F) | 1000 Parameter (500 F) | ||||||
ACOm | Ameisen-Kolonie-Optimierung M | 0.37458 | 0.28208 | 0.17991 | 0.83657 | 1.00000 | 1.00000 | 1.00000 | 3.00000 | 1.00000 | 1.00000 | 0.10959 | 2.10959 | 100.000 |
COAm | Kuckuck-Optimierungsalgorithmus M | 1.00000 | 0.73390 | 0.28892 | 2.02282 | 0.64504 | 0.34034 | 0.21362 | 1.19900 | 0.67153 | 0.34273 | 0.45422 | 1.46848 | 78.177 |
FAm | Firefly-Algorithmus M | 0.64746 | 0.53292 | 0.18102 | 1.36140 | 0.55408 | 0.42299 | 0.64360 | 1.62067 | 0.21167 | 0.28416 | 1.00000 | 1.49583 | 74.486 |
BA | Fledermaus-Algorithmus | 0.43859 | 1.00000 | 1.00000 | 2.43859 | 0.17768 | 0.17477 | 0.33595 | 0.68840 | 0.15329 | 0.07158 | 0.46287 | 0.68774 | 62.962 |
ABC | Künstliches Bienenvolk (Artificial Bee Colony, ABC) | 0.84599 | 0.51308 | 0.22588 | 1.58495 | 0.58850 | 0.21455 | 0.17249 | 0.97554 | 0.47444 | 0.26681 | 0.35941 | 1.10066 | 60.294 |
FSS | fish school search | 0.64746 | 0.53292 | 0.18102 | 1.36140 | 0.55408 | 0.42299 | 0.64360 | 1.62067 | 0.21167 | 0.28416 | 1.00000 | 1.49583 | 21.475 |
PSO | Partikelschwarmoptimierung | 0.22131 | 0.12861 | 0.05966 | 0.40958 | 0.15345 | 0.10486 | 0.28099 | 0.53930 | 0.08028 | 0.02385 | 0.00000 | 0.10413 | 14.971 |
RND | zufällig | 0.18210 | 0.15281 | 0.07011 | 0.40502 | 0.08623 | 0.04810 | 0.06094 | 0.19527 | 0.00000 | 0.00000 | 0.08904 | 0.08904 | 8.652 |
GWO | Grauer-Wolf-Optimierung | 0.00000 | 0.00000 | 0.00000 | 0.00000 | 0.00000 | 0.00000 | 0.00000 | 0.00000 | 0.18977 | 0.04119 | 0.01802 | 0.24898 | 1.000 |
Histogramm der Algorithmus-Testergebnisse in Abbildung 4
Abb. 4. Histogramm der Endergebnisse der Testalgorithmen
Schlussfolgerungen zu den Eigenschaften des Fledermaus-Algorithmus (BA):
Vorteile:
1. Hohe Geschwindigkeit.
2. Der Algorithmus funktioniert gut mit glatten Funktionen.
3. Skalierbarkeit.
Nachteile
1. Zu viele Einstellungen.
2. Mittelmäßige Ergebnisse zu diskreten Funktionen.
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/11915
- 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.