MetaTrader 5 / Beispiele
English Русский 中文 Español 日本語 Português 한국어 Français Italiano Türkçe
preview
Algorithmen zur Optimierung mit Populationen Fledermaus-Algorithmus (BA)

Algorithmen zur Optimierung mit Populationen Fledermaus-Algorithmus (BA)

MetaTrader 5 — Beispiele | 3 März 2023, 08:50
194 0
Andrey Dik
Andrey Dik

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.

Schema

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.

gamma

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.



Rastrigin

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.  

Rastrigin

  BA mit der Rastrigin-Testfunktion

Forest

BA mit dem Forest-Testfunktion

Megacity

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

Bewertung

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

Beigefügte Dateien |
ZIP herunterladen
9_The_world_of_AO_gBAs.zip (68.81 KB)
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.

Andere Artikel von diesem Autor

Zur Diskussion im Händlerforum
Algorithmen zur Populationsoptimierung Optimierung mit invasiven Unkräutern (IWO) Algorithmen zur Populationsoptimierung Optimierung mit invasiven Unkräutern (IWO)
Die erstaunliche Fähigkeit von Unkräutern, unter verschiedensten Bedingungen zu überleben, wurde zur Idee für einen leistungsstarken Optimierungsalgorithmus. IWO (Invasive Weed Optimization) ist einer der besten Algorithmen unter den bisher geprüften.
Experimente mit neuronalen Netzen (Teil 3): Praktische Anwendung Experimente mit neuronalen Netzen (Teil 3): Praktische Anwendung
In dieser Artikelserie entwickle ich mit Hilfe von Experimenten und unkonventionellen Ansätzen ein profitables Handelssystem und prüfe, ob neuronale Netze für Trader eine Hilfe sein können. MetaTrader 5 ist als autarkes Werkzeug für den Einsatz neuronaler Netze im Handel konzipiert.
Erstellen eines EA, der automatisch funktioniert (Teil 05): Manuelle Auslöser (II) Erstellen eines EA, der automatisch funktioniert (Teil 05): Manuelle Auslöser (II)
Heute werden wir sehen, wie man einen Expert Advisor erstellt, der einfach und sicher im automatischen Modus arbeitet. Am Ende des vorigen Artikels habe ich vorgeschlagen, dass es angebracht wäre, eine manuelle Nutzung des EA zuzulassen, zumindest für eine Weile.
Erstellen eines EA, der automatisch funktioniert (Teil 04): Manuelle Auslöser (I) Erstellen eines EA, der automatisch funktioniert (Teil 04): Manuelle Auslöser (I)
Heute werden wir sehen, wie man einen Expert Advisor erstellt, der einfach und sicher im automatischen Modus arbeitet.