
Algorithmen zur Optimierung mit Populationen Grauer-Wolf-Optimierung (GWO)
Inhalt
1. Einführung2. Beschreibung des Algorithmus
3. Testfunktionen
4. Testergebnisse
1. Einführung
Der Graue-Wolf-Algorithmus ist ein metaheuristischer, stochastischer Schwarmintelligenz-Algorithmus, der 2014 entwickelt wurde. Seine Idee basiert auf dem Modell der Jagd auf graue Wolfsrudel. Es gibt vier Arten von Wölfen: Alpha, Beta, Delta und Omega. Der Alpha hat das meiste „Gewicht“ bei der Entscheidungsfindung und der Führung des Rudels. Danach kommen die Beta- und die Delta-Wölfe, die dem Alpha gehorchen und Macht über die übrigen Wölfe haben. Der Omega-Wolf gehorcht immer dem Rest der dominanten Wölfe.
Im mathematischen Modell der Wolfshierarchie wird der Alpha-α-Wolf als der dominante Wolf im Rudel angesehen, und seine Befehle sollten von den Mitgliedern des Rudels ausgeführt werden. Beta-β-untergeordnete Wölfe unterstützen das Alphatier bei der Entscheidungsfindung und gelten als die besten Kandidaten für die Rolle des Alphatiers. Delta-Wölfe δ sollten Alpha und Beta gehorchen und sie beherrschen Omega. Omega ω-Wölfe gelten als die Sündenböcke des Rudels und als die unwichtigsten Individuen. Sie dürfen erst zum Schluss essen. Alpha wird als die günstigste Lösung angesehen.
Die zweit- und drittbeste Lösung sind Beta bzw. Delta. Die übrigen Lösungen gelten als Omega. Es wird davon ausgegangen, dass die fittesten Wölfe (Alpha, Beta und Delta), d. h. diejenigen, die der Beute am nächsten sind, vom Rest der Wölfe angegangen werden. Nach jeder Annäherung wird festgestellt, wer in dieser Phase Alpha, Beta und Delta ist, und dann werden die Wölfe wieder neu geordnet. Die Formation erfolgt so lange, bis sich die Wölfe zu einem Rudel zusammenfinden, das die optimale Richtung für einen Angriff mit minimalem Abstand darstellt.
Während des Algorithmus werden 3 Hauptphasen durchgeführt, in denen die Wölfe nach Beute suchen, sie einkreisen und angreifen. Die Suche ergibt Alpha, Beta und Delta - die Wölfe, die der Beute am nächsten sind. Der Rest, der den dominanten Tieren gehorcht, kann beginnen, die Beute zu einzukreisen oder sich auf der Suche nach der besten Möglichkeit wahllos zu bewegen.
2. Beschreibung des Algorithmus
Die Hierarchie im Paket ist in Abbildung 1 schematisch dargestellt. Alpha spielt eine dominante Rolle.
Abb. 1. Soziale Hierarchie in einem Wolfsrudel
Mathematisches Modell und Algorithmus
Soziale Hierarchie:
- Die beste Lösung in Form eines Alpha-Wolfs (α).
- Die zweitbeste Lösung als Beta-Wolf (β).
- Die drittbeste Lösung als Delta-Wolf (δ).
- Andere mögliche Lösungen als Omega-Wölfe (ω).
Einkreisen der Beute: Wenn es bereits die besten Alpha-, Beta- und Delta-Lösungen gibt, hängen die weiteren Aktionen von Omega ab.
Abb. 2. Jagdphasen: Suche, Einkreisung, Angriff.
Alle Iterationen des Algorithmus werden durch drei Phasen dargestellt: Suche, Umkreisung und Jagd. Die kanonische Version des Algorithmus zeichnet sich durch einen Koeffizienten а aus, der zur Verbesserung der Konvergenz des Algorithmus eingeführt wurde. Der Koeffizient sinkt bei jeder Iteration auf Null. Solange der Koeffizient über 1 liegt, werden die Wölfe initialisiert. In dieser Phase ist die Position der Beute völlig unbekannt, sodass die Wölfe nach dem Zufallsprinzip verteilt werden sollten.
Nach der „Suchphase“ wird der Wert der Fitnessfunktion bestimmt, und erst dann kann man zur „Einkreisungsphase“ übergehen. In dieser Phase ist der Koeffizient a größer als 1. Dies bedeutet, dass sich Alpha, Beta und Delta von ihren vorherigen Positionen entfernen und somit die Position der geschätzten Beute verfeinert werden kann. Wenn der Koeffizient а gleich 1 wird, beginnt die „Angriffsphase“, während der Koeffizient vor dem Ende der Iterationen gegen 0 tendiert. Dies veranlasst die Wölfe, sich der Beute zu nähern, was darauf hindeutet, dass die beste Position bereits gefunden wurde. Wenn in dieser Phase einer der Wölfe eine bessere Lösung findet, werden zwar die Position der Beute und die Hierarchie der Wölfe aktualisiert, aber der Koeffizient tendiert weiterhin gegen 0. Der Prozess der Veränderung von a wird durch eine nichtlineare Funktion dargestellt. Die Phasen sind in Abbildung 2 schematisch dargestellt.
Das Verhalten der Omega-Wölfe ist in allen Epochen unverändert und besteht darin, der geometrischen Mitte zwischen den Positionen der derzeit dominanten Individuen zu folgen. In Abbildung 3 weichen Alpha, Beta und Delta von ihrer vorherigen Position in einer zufälligen Richtung mit einem Radius ab, der durch die Koeffizienten gegeben ist, und Omegas bewegen sich zur Mitte zwischen ihnen, weichen aber mit einer gewissen Wahrscheinlichkeit innerhalb des Radius von ihr ab. Die Radien bestimmen den Koeffizienten а, der sich, wie wir uns erinnern, ändert, wodurch die Radien proportional abnehmen.
Abb. 3. Diagramm der Omega-Bewegung im Verhältnis zu Alpha, Beta und Delta
Der Pseudocode des GWO-Algorithmus lautet wie folgt:
1) Initialisieren der Population der Grauen Wölfe nach dem Zufallsprinzip.
2) Berechnen der Fitness der einzelnen Mitglieder der Population.
3) Rudelführer:
-α = Mitglied mit dem besten Fitnesswert
-β = zweitbestes Mitglied (in Bezug auf die Fitness)
-δ = drittbestes Mitglied (in Bezug auf den Fitnesswert)
Aktualisierung der Position aller Omega-Wölfe gemäß den Gleichungen, die von α, β, δ abhängen
4) Berechnen der Fitness der einzelnen Mitglieder der Population.
5) Schritt 3 wiederholen.
Kommen wir nun zum Algorithmus selbst. Die einzige Ergänzung, die ich gegenüber der ursprünglichen Version vorgenommen habe, ist die Möglichkeit, die Anzahl der Leitwölfe im Rudel festzulegen. Jetzt können wir eine beliebige Anzahl von Anführern festlegen, bis hin zum gesamten Rudel. Dies kann für bestimmte Aufgaben nützlich sein.
Wir beginnen, wie üblich, mit der elementaren Einheit des Algorithmus - dem Wolf, der eine Lösung des Problems darstellt. Dies ist eine Struktur, die eine Reihe von Koordinaten und einen Beutewert (Fitnessfunktionen) enthält. Die Struktur ist für Anführer und untergeordnete Mitglieder des Rudels gleich. Dies vereinfacht den Algorithmus und ermöglicht es uns, dieselben Strukturen in den Schleifenoperationen zu verwenden. Außerdem wechseln die Rollen der Wölfe während aller Iterationen mehrmals. Die Rollen sind eindeutig durch die Position im Array nach der Sortierung bestimmt. Die Anführer stehen am Anfang der Reihe.
//—————————————————————————————————————————————————————————————————————————————— struct S_Wolf { double c []; //coordinates double p; //prey }; //——————————————————————————————————————————————————————————————————————————————
Das Wolfsrudel wird durch eine kompakte und verständliche Klasse repräsentiert. Hier geben wir die Bereiche und den Schritt der zu optimierenden Parameter, die beste Produktionsposition, den besten Lösungswert und Hilfsfunktionen an.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_GWO //wolfpack { //============================================================================ public: double rangeMax []; //maximum search range public: double rangeMin []; //manimum search range public: double rangeStep []; //step search public: S_Wolf wolves []; //wolves of the pack public: double cB []; //best prey coordinates public: double pB; //best prey public: void InitPack (const int coordinatesP, //number of opt. parameters const int wolvesNumberP, //wolves number const int alphaNumberP, //alpha beta delta number const int epochCountP); //epochs number public: void TasksForWolves (int epochNow); public: void RevisionAlphaStatus (); //============================================================================ private: void ReturnToRange (S_Wolf &wolf); private: void SortingWolves (); private: double SeInDiSp (double In, double InMin, double InMax, double Step); private: double RNDfromCI (double Min, double Max); private: int coordinates; //coordinates number private: int wolvesNumber; //the number of all wolves private: int alphaNumber; //Alpha beta delta number of all wolves private: int epochCount; private: S_Wolf wolvesT []; //temporary, for sorting private: int ind []; //array for indexes when sorting private: double val []; //array for sorting private: bool searching; //searching flag }; //——————————————————————————————————————————————————————————————————————————————
Traditionell folgt auf die Klassendeklaration die Initialisierung. Hier setzen wir auf den minimalen „double“ Wert der Fitness der Wölfe zurück und verteilen die Größe der Felder.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_GWO::InitPack (const int coordinatesP, //number of opt. parameters const int wolvesNumberP, //wolves number const int alphaNumberP, //alpha beta delta number const int epochCountP) //epochs number { MathSrand (GetTickCount ()); searching = false; pB = -DBL_MAX; coordinates = coordinatesP; wolvesNumber = wolvesNumberP; alphaNumber = alphaNumberP; epochCount = epochCountP; ArrayResize (rangeMax, coordinates); ArrayResize (rangeMin, coordinates); ArrayResize (rangeStep, coordinates); ArrayResize (cB, coordinates); ArrayResize (ind, wolvesNumber); ArrayResize (val, wolvesNumber); ArrayResize (wolves, wolvesNumber); ArrayResize (wolvesT, wolvesNumber); for (int i = 0; i < wolvesNumber; i++) { ArrayResize (wolves [i].c, coordinates); ArrayResize (wolvesT [i].c, coordinates); wolves [i].p = -DBL_MAX; wolvesT [i].p = -DBL_MAX; } } //——————————————————————————————————————————————————————————————————————————————
Die erste öffentliche Methode, die bei jeder Iteration aufgerufen wird, ist am schwierigsten zu verstehen und am umfangreichsten. Hier ist die Hauptlogik des Algorithmus. Die Leistung des Algorithmus wird nämlich durch einen probabilistischen Mechanismus gewährleistet, der streng durch Gleichungen beschrieben wird. Gehen wir diese Methode Schritt für Schritt durch. Bei der ersten Iteration, wenn die Position der beabsichtigten Beute unbekannt ist, schicken wir die Wölfe nach der Überprüfung der Flag in eine zufällige Richtung, indem wir einfach Werte aus den Maximal- und Minimalwerten der optimierten Parameter generieren.
//---------------------------------------------------------------------------- //space has not been explored yet, then send the wolf in a random direction if (!searching) { for (int w = 0; w < wolvesNumber; w++) { for (int c = 0; c < coordinates; c++) { wolves [w].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]); wolves [w].c [c] = SeInDiSp (wolves [w].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } } searching = true; return; }
In der kanonischen Version der Algorithmusbeschreibung gibt es Gleichungen, die mit Vektoren arbeiten. In Codeform sind sie jedoch viel deutlicher. Die Berechnung der Omega-Wölfe wird vor der Berechnung der Alpha-, Beta- und Delta-Wölfe durchgeführt, da wir die vorherigen Leader-Werte verwenden müssen.
Die Hauptkomponente, die die drei Phasen der Jagd (Suchen, Einkreisen und Angriff) ermöglicht, ist der Koeffizient a. Er stellt eine nichtlineare Abhängigkeit von der aktuellen Iteration und der Gesamtzahl der Iterationen dar und tendiert gegen 0.Die nächsten Komponenten der Gleichung sind Ai und Сi:
- Ai = 2,0 * a * r1 - a;
- Ci = 2,0 * r2;
In dem Ausdruck
//---------------------------------------------------------------------------- double a = sqrt (2.0 * (1.0 - (epochNow / epochCount))); double r1 = 0.0; double r2 = 0.0; double Ai = 0.0; double Ci = 0.0; double Xn = 0.0; double min = 0.0; double max = 1.0; //omega----------------------------------------------------------------------- for (int w = alphaNumber; w < wolvesNumber; w++) { Xn = 0.0; for (int c = 0; c < coordinates; c++) { for (int abd = 0; abd < alphaNumber; abd++) { r1 = RNDfromCI (min, max); r2 = RNDfromCI (min, max); Ai = 2.0 * a * r1 - a; Ci = 2.0 * r2; Xn += wolves [abd].c [c] - Ai * (Ci * wolves [abd].c [c] - wolves [w].c [c]); } wolves [w].c [c] = Xn /= (double)alphaNumber; } ReturnToRange (wolves [w]); }
Hier werden die Anführer berechnet. Für sie werden die Koeffizienten a, Ai und Ci für jede Koordinate berechnet. Der einzige Unterschied besteht darin, dass sich die Position der Anführer im Verhältnis zu den besten Beutekoordinaten zum aktuellen Zeitpunkt und ihren eigenen Positionen ändert. Die Anführer kreisen die Beute ein, bewegen sich nach innen und außen und kontrollieren die kleineren Wölfe bei ihrem Angriff.
//alpha, beta, delta---------------------------------------------------------- for (int w = 0; w < alphaNumber; w++) { for (int c = 0; c < coordinates; c++) { r1 = RNDfromCI (min, max); r2 = RNDfromCI (min, max); Ai = 2.0 * a * r1 - a; Ci = 2.0 * r2; wolves [w].c [c] = cB [c] - Ai * (Ci * cB [c] - wolves [w].c [c]); } ReturnToRange (wolves [w]); }
Dies ist die zweite öffentliche Methode, die bei jeder Iteration aufgerufen wird. Der Status der Führenden im Rudel wird hier aktualisiert. Die Wölfe sind nämlich nach ihrem Fitnesswert sortiert. Wenn bessere Beutekoordinaten als die im Schwarm gespeicherten gefunden werden, aktualisieren wir die Werte.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_GWO::RevisionAlphaStatus () { SortingWolves (); if (wolves [0].p > pB) { pB = wolves [0].p; ArrayCopy (cB, wolves [0].c, 0, 0, WHOLE_ARRAY); } } //——————————————————————————————————————————————————————————————————————————————
3. Testfunktionen
Sie kennen bereits die Funktionen Skin, Forest und Megacity. Diese Testfunktionen erfüllen alle Komplexitätskriterien für das Testen von Optimierungsalgorithmen. Es gibt jedoch eine Besonderheit, die nicht berücksichtigt wurde. Sie sollte eingeführt werden, um die Objektivität der Prüfung zu erhöhen. Die Anforderungen sind wie folgt:
- Das globale Extremum sollte nicht an den Grenzen des Bereichs liegen. Verfügt der Algorithmus nicht über eine Bereichsüberschreitungsprüfung, sind Situationen möglich, in denen der Algorithmus hervorragende Ergebnisse liefert. Dies ist darauf zurückzuführen, dass die Werte aufgrund eines internen Fehlers an den Rändern liegen werden.
- Das globale Extremum sollte nicht in der Mitte der Koordinaten des Bereichs liegen. In diesem Fall wird der Algorithmus, der in einem Bereich gemittelte Werte erzeugt, berücksichtigt.
- Das globale Minimum sollte sich in der Mitte der Koordinaten befinden. Dies ist notwendig, um die auf S. 2 beschriebenen Situationen bewusst auszuschließen.
- Bei der Berechnung der Ergebnisse der Testfunktion sollte der Fall berücksichtigt werden, dass zufällig erzeugte Zahlen über den gesamten Bereich der Funktion (wenn es sich um eine multivariable Funktion handelt) ein durchschnittliches Ergebnis von etwa 50 % des Maximums ergeben, obwohl diese Ergebnisse tatsächlich zufällig erzielt wurden.
Unter Berücksichtigung dieser Anforderungen wurden die Grenzen der Testfunktionen überarbeitet und die Mittelpunkte des Bereichs auf die Minima der Funktionswerte verschoben. Fassen wir noch noch einmal zusammen. Dies war notwendig, um eine größtmögliche Plausibilität und Objektivität der Ergebnisse der Testoptimierungsalgorithmen zu erreichen. Daher zeigte der Optimierungsalgorithmus, der auf der Erzeugung von Zufallszahlen basiert, bei neuen Testfunktionen ein natürlich niedriges Gesamtergebnis. Die aktualisierte Bewertungstabelle befindet sich am Ende des Artikels.
Die Skin-Funktion. Eine glatte Funktion, die mehrere lokale Extrema aufweist, die den Optimierungsalgorithmus verwirren können, da er in einem von ihnen stecken bleiben kann. Das einzige globale Extremum ist durch schwach wechselnde Werte in der Umgebung gekennzeichnet. Diese Funktion zeigt deutlich, dass der Algorithmus in verschiedene Bereiche unterteilt werden kann, anstatt sich auf einen einzigen Bereich zu konzentrieren. Insbesondere der Bienenvolk-Algorithmus (ABC) verhält sich auf diese Weise.
Abb. 4. Funktion des Skin-Tests
Die Forest-Funktion. Eine Funktion mit mehreren glatten und mehreren nicht-differenzierbaren Extrema. Dies ist ein wertvoller Test für Optimierungsalgorithmen, um eine „Nadel im Heuhaufen“ zu finden. Die Suche nach einem einzigen globalen Maximalpunkt ist eine sehr schwierige Aufgabe, insbesondere wenn die Funktion viele Variablen enthält. Der Ameisenkolonie-Algorithmus (ACO) zeichnet sich bei dieser Aufgabe durch das charakteristische Verhalten aus, das auf unglaubliche Weise Wege zum Ziel bahnt.
Abbildung 5, Testfunktion von Forest
Die Megacity-Funktion. Die Funktion ist ein diskretes Optimierungsproblem mit einem globalen und mehreren lokalen Extrema. Die extrem komplexe Oberfläche bietet einen guten Test für Algorithmen, die einen Gradienten benötigen. Eine zusätzliche Komplexität wird durch einen völlig ebenen „Boden“ hinzugefügt, der ebenfalls ein Minimum ist, das keine Informationen über die mögliche Richtung zum globalen Maximum gibt.
Abbildung 6, Testfunktion von Megacity
Der Code der Testfunktionen wurde um Überprüfungen der eingehenden Argumente auf Werte außerhalb des zulässigen Bereichs erweitert. In den früheren Versionen der Funktionen konnten Optimierungsalgorithmen auf unfaire Weise Funktionswerte erhalten, die größer waren als die tatsächlichen Werte der Funktion innerhalb ihres Definitionsbereichs.
4. Testergebnisse
Aufgrund der Änderungen der Prüffunktionen wurde auch der Prüfstand aktualisiert. Auf der rechten Seite des Standbildschirms sind weiterhin die Konvergenzkurven der Optimierungsalgorithmen zu sehen. Die grüne Linie steht für die Ergebnisse der Konvergenz bei Funktionen mit zwei Variablen. Die blaue Linie steht für die Funktionen mit 40 Variablen. Die rote Farbe steht für Funktionen mit 1000 Variablen. Der größere schwarze Kreis zeigt die Position des globalen Maximums der Funktion an. Der kleinere schwarze Kreis zeigt die Position des aktuellen Lösungswertes des Optimierungsalgorithmus an. Das Fadenkreuz aus weißen Linien zeigt den geometrischen Mittelpunkt der Testfunktionen und entspricht dem globalen Minimum. Dies wurde eingeführt, um das Verhalten der getesteten Algorithmen besser sichtbar zu machen. Die weißen Punkte zeigen gemittelte Zwischenlösungen an. Farbige kleine Punkte kennzeichnen Koordinatenpaare der entsprechenden Dimension. Die Farbe gibt die ordinale Position der Dimension der Testfunktion an.
Die aktualisierten Ergebnisse der Tests der in früheren Artikeln besprochenen Optimierungsalgorithmen auf dem neuen Stand sind in der aktualisierten Tabelle zu sehen. Für mehr visuelle Klarheit wurde die Zeile über die Konvergenzgeschwindigkeit aus der Tabelle entfernt - sie kann auf der Animation des Standes visuell bestimmt werden. Die Spalte mit der Algorithmusbeschreibung wurde hinzugefügt.
ACO (Ant Colony Optimization) Testergebnisse:
2022.11.28 12:17:00.468 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:17:06.382 Test_AO_ABCm (EURUSD,M1) 1 Skins; Funktionsdurchläufe 10000 Ergebnis: 4.844203223078298
2022.11.28 12:17:06.382 Test_AO_ACO (EURUSD,M1) Ergebnis: 0.98229.
2022.11.28 12:17:14.191 Test_AO_ABCm (EURUSD,M1) 20 Skins; Funktionsdurchläufe 10000 Ergebnis: 4.043383610736287
2022.11.28 12:17:14.191 Test_AO_ACO (EURUSD,M1) Ergebnis: 0.79108.
2022.11.28 12:17:55.578 Test_AO_ABCm (EURUSD,M1) 500 Skins; Funktionsdurchläufe 10000 Ergebnis: 1.2580170651681026
2022.11.28 12:17:55.578 Test_AO_ACO (EURUSD,M1) Ergebnis: 0.12602.
2022.11.28 12:17:55.578 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:18:01.491 Test_AO_ABCm (EURUSD,M1) 1 Forests; Funktionsdurchläufe 10000 Ergebnis: 1.7678766100234538
2022.11.28 12:18:01.491 Test_AO_ACO (EURUSD,M1) Ergebnis: 1.00000
2022.11.28 12:18:09.508 Test_AO_ABCm (EURUSD,M1) 20 Forests; Funktionsdurchläufe 10000 Ergebnis: 1.0974381500585855
2022.11.28 12:18:09.508 Test_AO_ACO (EURUSD,M1) Ergebnis: 0.62077.
2022.11.28 12:18:53.348 Test_AO_ABCm (EURUSD,M1) 500 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.20367726028454042
2022.11.28 12:18:53.348 Test_AO_ACO (EURUSD,M1) Ergebnis: 0.11521.
2022.11.28 12:18:53.348 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:18:59.303 Test_AO_ABCm (EURUSD,M1) 1 Megacity; Funktionsdurchläufe 10000 Ergebnis: 4.6
2022.11.28 12:18:59.303 Test_AO_ACO (EURUSD,M1) Ergebnis: 0.38333.
2022.11.28 12:19:07.598 Test_AO_ACO (EURUSD,M1) 20 Megacities; Funktionsdurchläufe 10000 Ergebnis: 5.28.
2022.11.28 12:19:07.598 Test_AO_ACO (EURUSD,M1) Ergebnis: 0.44000.
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) 500 Megacities; Funktionsdurchläufe 10000 Ergebnis: 0.2852.
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) Ergebnis: 0.02377.
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:19:53.172 Test_AO_M1 (EURUSD,M1) Alle Ergebnisse für C_AO_ABC: 0.4980520084646583
ABCm (Künstliches Bienenvolk) Testergebnisse:
2022.11.28 12:35:47.181 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:35:52.581 Test_AO_ABCm (EURUSD,M1) 1 Skins; Funktionsdurchläufe 10000 Ergebnis: 4.918379986612587
2022.11.28 12:35:52.581 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 1.00000
2022.11.28 12:35:59.454 Test_AO_ABCm (EURUSD,M1) 20 Skins; Funktionsdurchläufe 10000 Ergebnis: 3.4073825805846374
2022.11.28 12:35:59.454 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 0.63922.
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) 500 Skins; Funktionsdurchläufe 10000 Ergebnis: 1.0684464927353337
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 0.08076
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:36:38.086 Test_AO_ABCm (EURUSD,M1) 1 Forest; Funktionsdurchläufe 10000 Ergebnis: 1.766245456669898
2022.11.28 12:36:38.086 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 0.99908.
2022.11.28 12:36:45.326 Test_AO_ABCm (EURUSD,M1) 20 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.35556125136004335
2022.11.28 12:36:45.326 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 0.20112
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) 500 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.06691711149962026
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 0.03785.
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:37:28.047 Test_AO_ABCm (EURUSD,M1) 1 Megacity; Funktionsdurchläufe 10000 Ergebnis: 12.0.
2022.11.28 12:37:28.047 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 1.00000
2022.11.28 12:37:35.689 Test_AO_ABCm (EURUSD,M1) 20 Megacities; Funktionsdurchläufe 10000 Ergebnis: 1.9600000000000002
2022.11.28 12:37:35.689 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 0.16333.
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) 500 Megacities; Funktionsdurchläufe 10000 Ergebnis: 0.33880000000000005
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) Ergebnis1: 0.02823.
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) All score for C_AO_ABCm: 0.4610669021761763
ABC (Artificial Bee Colony) Testergebnisse:
2022.11.28 12:29:51.177 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:29:56.785 Test_AO_ABCm (EURUSD,M1) 1 Skins; Funktionsdurchläufe 10000 Ergebnis: 4.890679983950205
2022.11.28 12:29:56.785 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.99339.
2022.11.28 12:30:03.880 Test_AO_ABCm (EURUSD,M1) 20 Skins; Funktionsdurchläufe 10000 Ergebnis: 3.8035430744604133
2022.11.28 12:30:03.880 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.73381.
2022.11.28 12:30:37.089 Test_AO_ABCm (EURUSD,M1) 500 Skins; Funktionsdurchläufe 10000 Ergebnis: 1.195840100227333
2022.11.28 12:30:37.089 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.11118.
2022.11.28 12:30:37.089 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:30:42.811 Test_AO_ABCm (EURUSD,M1) 1 Forests; Funktionsdurchläufe 10000 Ergebnis: 1.7667070507449298
2022.11.28 12:30:42.811 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.99934.
2022.11.28 12:30:50.108 Test_AO_ABCm (EURUSD,M1) 20 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.3789854806095275
2022.11.28 12:30:50.108 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.21437.
2022.11.28 12:31:25.900 Test_AO_ABCm (EURUSD,M1) 500 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.07451308481273813
2022.11.28 12:31:25.900 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.04215.
2022.11.28 12:31:25.900 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:31:31.510 Test_AO_ABCm (EURUSD,M1) 1 Megacities; Funktionsdurchläufe 10000 Ergebnis: 10.2
2022.11.28 12:31:31.510 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.85000.
2022.11.28 12:31:38.855 Test_AO_ABCm (EURUSD,M1) 20 Megacities; Funktionsdurchläufe 10000 Ergebnis: 2.02
2022.11.28 12:31:38.855 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.16833.
2022.11.28 12:32:14.623 Test_AO_ABCm (EURUSD,M1) 500 Megacities; Funktionsdurchläufe 10000 Ergebnis: 0.37559999999999993
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) Ergebnis: 0.03130.
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:32:14.623 Test_AO_M1 (EURUSD,M1) All score for C_AO_ABC: 0.46043003186219245
PSO (Partikelschwarm-Optimierung) Testergebnisse
2022.11.28 12:01:03.967 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:01:09.723 Test_AO_ABCm (EURUSD,M1) 1 Skins; Funktionsdurchläufe 10000 Ergebnis: 4.90276049713715
2022.11.28 12:01:09.723 Test_AO_PSO (EURUSD,M1) Ergebnis: 0.99627.
2022.11.28 12:01:17.064 Test_AO_ABCm (EURUSD,M1) 20 Skins; Funktionsdurchläufe 10000 Ergebnis: 2.3250668562024566
2022.11.28 12:01:17.064 Test_AO_PSO (EURUSD,M1) Ergebnis: 0.38080.
2022.11.28 12:01:52.880 Test_AO_ABCm (EURUSD,M1) 500 Skins; Funktionsdurchläufe 10000 Ergebnis: 0.943331687769892
2022.11.28 12:01:52.881 Test_AO_PSO (EURUSD,M1) Ergebnis: 0.05089.
2022.11.28 12:01:52.881 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:01:58.492 Test_AO_ABCm (EURUSD,M1) 1 Forests; Funktionsdurchläufe 10000 Ergebnis: 1.6577769478566602
2022.11.28 12:01:58.492 Test_AO_PSO (EURUSD,M1) Ergebnis: 0.93772.
2022.11.28 12:02:06.105 Test_AO_ABCm (EURUSD,M1) 20 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.25704414127018393
2022.11.28 12:02:06.105 Test_AO_PSO (EURUSD,M1) Ergebnis: 0.14540.
2022.11.28 12:02:44.566 Test_AO_ABCm (EURUSD,M1) 500 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.08584805450831333
2022.11.28 12:02:44.566 Test_AO_PSO (EURUSD,M1) Ergebnis: 0.04856.
2022.11.28 12:02:44.566 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:02:50.268 Test_AO_ABCm (EURUSD,M1) 1 Megacities; Funktionsdurchläufe 10000 Ergebnis: 12.0.
2022.11.28 12:02:50.268 Test_AO_PSO (EURUSD,M1) Ergebnis: 1.00000
2022.11.28 12:02:57.649 Test_AO_PSO (EURUSD,M1) 20 Megacity's; Func läuft 10000 Ergebnis: 1.1199999999999999
2022.11.28 12:02:57.649 Test_AO_PSO (EURUSD,M1) Ergebnis: 0.09333.
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) 500 Megacity's; Func läuft 10000 Ergebnis: 0.268
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) Ergebnis: 0.02233.
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) Alle Ergebnisse für C_AO_PSO: 0.40836715689743186
RND (Random) Testergebnisse:
2022.11.28 16:45:15.976 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:45:21.569 Test_AO_ABCm (EURUSD,M1) 1 Skins; Funktionsdurchläufe 10000 Ergebnis: 4.915522750114194
2022.11.28 16:45:21.569 Test_AO_RND (EURUSD,M1) Ergebnis: 0.99932.
2022.11.28 16:45:28.607 Test_AO_ABCm (EURUSD,M1) 20 Skins; Funktionsdurchläufe 10000 Ergebnis: 2.584546688199847
2022.11.28 16:45:28.607 Test_AO_RND (EURUSD,M1) Ergebnis: 0.44276.
2022.11.28 16:46:02.695 Test_AO_ABCm (EURUSD,M1) 500 Skins; Funktionsdurchläufe 10000 Ergebnis: 1.0161336237263792
2022.11.28 16:46:02.695 Test_AO_RND (EURUSD,M1) Ergebnis: 0.06827.
2022.11.28 16:46:02.695 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:46:09.622 Test_AO_ABCm (EURUSD,M1) 1 Forests; Funktionsdurchläufe 10000 Ergebnis: 1.4695680943894533
2022.11.28 16:46:09.622 Test_AO_RND (EURUSD,M1) Ergebnis: 0.83126.
2022.11.28 16:46:17.675 Test_AO_ABCm (EURUSD,M1) 20 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.20373533112604475
2022.11.28 16:46:17.675 Test_AO_RND (EURUSD,M1) Ergebnis: 0.11524.
2022.11.28 16:46:54.544 Test_AO_ABCm (EURUSD,M1) 500 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.0538909816827325
2022.11.28 16:46:54.544 Test_AO_RND (EURUSD,M1) Ergebnis: 0.03048.
2022.11.28 16:46:54.544 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:47:00.219 Test_AO_ABCm (EURUSD,M1) 1 Megacities; Funktionsdurchläufe 10000 Ergebnis: 10.0.
2022.11.28 16:47:00.219 Test_AO_RND (EURUSD,M1) Ergebnis: 0.83333.
2022.11.28 16:47:08.145 Test_AO_ABCm (EURUSD,M1) 20 Megacities; Funktionsdurchläufe 10000 Ergebnis: 1.08
2022.11.28 16:47:08.145 Test_AO_RND (EURUSD,M1) Ergebnis: 0.09000.
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) 500 Megacity's; Func läuft 10000 Ergebnis: 0.28840000000000005
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) Ergebnis: 0.02403.
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) Alle Ergebnisse für C_AO_RND: 0.38163317904126015
ACO mit der Testfunktion Skin
ACO mit der Testfunktion Forest
ACO mit der Testfunktion Megacity
GWO-Testergebnisse.
2022.11.28 13:24:09.370 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:24:14.895 Test_AO_ABCm (EURUSD,M1) 1 Skins; Funktionsdurchläufe 10000 Ergebnis: 4.914175888065222
2022.11.28 13:24:14.895 Test_AO_GWO (EURUSD,M1) Ergebnis: 0.99900
2022.11.28 13:24:22.175 Test_AO_ABCm (EURUSD,M1) 20 Skins; Funktionsdurchläufe 10000 Ergebnis: 2.7419092435309405
2022.11.28 13:24:22.175 Test_AO_GWO (EURUSD,M1) Ergebnis: 0.48033.
2022.11.28 13:25:01.381 Test_AO_ABCm (EURUSD,M1) 500 Skins; Funktionsdurchläufe 10000 Ergebnis: 1.5227848592798188
2022.11.28 13:25:01.381 Test_AO_GWO (EURUSD,M1) Ergebnis: 0.18924.
2022.11.28 13:25:01.381 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:25:06.924 Test_AO_ABCm (EURUSD,M1) 1 Forests; Funktionsdurchläufe 10000 Ergebnis: 1.4822580151819842
2022.11.28 13:25:06.924 Test_AO_GWO (EURUSD,M1) Ergebnis: 0.83844.
2022.11.28 13:25:14.551 Test_AO_ABCm (EURUSD,M1) 20 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.15477395149266915
2022.11.28 13:25:14.551 Test_AO_GWO (EURUSD,M1) Ergebnis: 0.08755.
2022.11.28 13:25:56.900 Test_AO_ABCm (EURUSD,M1) 500 Forests; Funktionsdurchläufe 10000 Ergebnis: 0.04517298232457319
2022.11.28 13:25:56.900 Test_AO_GWO (EURUSD,M1) Ergebnis: 0.02555.
2022.11.28 13:25:56.900 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:26:02.305 Test_AO_ABCm (EURUSD,M1) 1 Megacity; Funktionsdurchläufe 10000 Ergebnis: 12.0.
2022.11.28 13:26:02.305 Test_AO_GWO (EURUSD,M1) Ergebnis: 1.00000
2022.11.28 13:26:09.475 Test_AO_ABCm (EURUSD,M1) 20 Megacities; Funktionsdurchläufe 10000 Ergebnis: 1.2
2022.11.28 13:26:09.475 Test_AO_GWO (EURUSD,M1) Ergebnis: 0.10000
2022.11.28 13:26:48.980 Test_AO_ABCm (EURUSD,M1) 500 Megacities; Funktionsdurchläufe 10000 Ergebnis: 0.2624.
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) Ergebnis: 0.02187.
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) Alle Ergebnisse für C_AO_GWO: 0.41577484361261224
Der Graue-Wölfe-Optimierungsalgorithmus (GWO) ist einer der jüngsten bio-inspirierten Optimierungsalgorithmen, der auf der simulierten Jagd eines Rudels grauer Wölfe basiert. Im Durchschnitt hat sich der Algorithmus bei verschiedenen Funktionstypen als recht effizient erwiesen, sowohl was die Genauigkeit bei der Suche nach einem Extremum als auch was die Konvergenzgeschwindigkeit betrifft. In einigen Tests hat sie sich als der beste herausgestellt. Die wichtigsten Leistungsindikatoren des Optimierungsalgorithmus „Graue Wölfe“ sind besser als die des Algorithmus der Partikelschwarmoptimierung, der als „konventionell“ in der Klasse der bio-inspirierten Optimierungsalgorithmen gilt.
Gleichzeitig ist die Rechenkomplexität des Graue-Wölfe-Optimierungsalgorithmus vergleichbar mit der des Partikelschwarm-Optimierungsalgorithmus. Aufgrund der zahlreichen Vorteile des GWO-Optimierungsalgorithmus sind in der kurzen Zeit seit der ersten Veröffentlichung des Algorithmus viele Arbeiten zu seiner Modifizierung erschienen. Der einzige Nachteil des Algorithmus ist die geringe Genauigkeit der gefundenen Koordinaten der Funktion sharp-maximum für Forest,
Die geringe Genauigkeit des gefundenen Extremwerts zeigte sich in allen Dimensionen der Forest-Funktion, und die Ergebnisse sind die schlechtesten unter allen Teilnehmern in der Tabelle. Der Algorithmus erwies sich bei der glatten Skin-Funktion als effizient, insbesondere bei der Skin-Funktion mit größerer Dimension. GWO ist auch der Dritte in der Tabelle, der bei der Funktion Megacity einen Treffer von 100 % beim globalen Maximum erzielt.
AO | Beschreibung | Skin | Forest | Megacity (diskret) | Endergebnis | ||||||
2 Parameter (1 F) | 40 Parameter (20 F) | 1000 Parameter (500 F) | 2 Parameter (1 F) | 40 Parameter (20 F) | 1000 Parameter (500 F) | 2 Parameter (1 F) | 40 Parameter (20 F) | 1000 Parameter (500 F) | |||
Ameisenkolonie-Optimierung (ACO) | 0.98229. | 0.79108. | 0.12602. | 1.00000 | 0.62077. | 0.11521. | 0.38333. | 0.44000. | 0.02377. | 0.49805222 | |
Künstliches Bienenvolk (Artificial Bee Colony, ABC) | 1.00000 | 0.63922. | 0.08076 | 0.99908. | 0.20112 | 0.03785. | 1.00000 | 0.16333. | 0.02823. | 0.46106556 | |
Künstliches Bienenvolk (Artificial Bee Colony, ABC) | 0.99339. | 0.73381. | 0.11118. | 0.99934. | 0.21437. | 0.04215. | 0.85000. | 0.16833. | 0.03130. | 0.46043000 | |
Grauer-Wolf-Optimierung | 0.99900 | 0.48033. | 0.18924. | 0.83844. | 0.08755. | 0.02555. | 1.00000 | 0.10000 | 0.02187. | 0.41577556 | |
Partikelschwarmoptimierung | 0.99627. | 0.38080. | 0.05089. | 0.93772. | 0.14540. | 0.04856. | 1.00000 | 0.09333. | 0.02233. | 0.40836667 | |
zufällig | 0.99932. | 0.44276. | 0.06827. | 0.83126. | 0.11524. | 0.03048. | 0.83333. | 0.09000. | 0.02403. | 0.38163222 |
Schlussfolgerungen:
Vorteile:
1. Hohe Geschwindigkeit.
2. Hohe Konvergenz für glatte Funktionen mit einer großen Anzahl von Variablen.
Nachteile
1. Nicht universell.
2. Feststecken in lokalen Extremen.
3. Geringe Skalierbarkeit bei diskreten und nicht-differenzierbaren Funktionen.
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/11785





- 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.