MetaTrader 5 / Beispiele
English Русский Português
preview
Kometenschweif-Algorithmus (CTA)

Kometenschweif-Algorithmus (CTA)

MetaTrader 5 — Beispiele | 11 Oktober 2024, 11:23
24 0
Andrey Dik
Andrey Dik

Inhalt

1. Einführung
2. Implementierung des Algorithmus
3Testergebnisse


1. Einführung

In der Welt der Astronomie waren Kometen schon immer von besonderem Interesse für Wissenschaftler und Forscher. Diese einzigartigen Weltraumobjekte, die hauptsächlich aus Eis, Staub und Gasen bestehen, sind eine wichtige Quelle für Informationen über die Prozesse im Weltraum. Einer der auffälligsten und beeindruckendsten Aspekte von Kometen ist ihr Schweif, der sich bildet, wenn sich der Komet der Sonne nähert.

Die Sonne spielt eine Schlüsselrolle bei der Bildung des Kometenschweifs. Seine Strahlung und der Sonnenwind bewirken die Verdunstung und Zerstörung von Material auf der Kometenoberfläche. Dieser Prozess führt zur Bildung eines Kometenschweifs — ein Bereich aus Staub, Gasen und ionisierten Teilchen, die durch den Sonnenwind und die Schwerkraft der Sonne vom Kometen weggedrückt werden.

In diesem Artikel befassen wir uns mit dem Optimierungsalgorithmus des Kometenschweifs, CTA (Comet Tail Algorithm), der von diesem einzigartigen astronomischen Phänomen inspiriert wurde. Der CTA-Algorithmus nutzt das Konzept der Kometenbewegung und ihrer Schweife, um optimale Lösungen für Optimierungsprobleme zu finden. Wir werden uns die Bewegung des Kometen und seines Schweifs sowie die Rolle der Sonne bei diesen Prozessen genau ansehen. Wir werden auch erörtern, wie diese Konzepte im CTA-Algorithmus angewendet werden, um effektiv optimale Lösungen zu finden.

Kometen sind kleine Körper im Sonnensystem, die verdampfen und Gase freisetzen, wenn sie sich der Sonne nähern. Dieser Vorgang wird als Sublimation bezeichnet. Kometen haben typischerweise stark elliptische Bahnen und eine große Bandbreite an Umlaufzeiten - von einigen Jahren bis hin zu mehreren Millionen Jahren.

Die Bewegung eines Kometen und seines Schweifs ist eng mit dem Einfluss der Sonne verbunden. Durch die Hitze der Sonne verwandelt sich das Kometeneis in Gase, wodurch sich die Koma (die Gashülle, die den Kometenkern umgibt) ausdehnt. Der Druck der Sonnenstrahlung und der schnellen Sonnenteilchen (Sonnenwind) kann Staub und Gas der Koma von der Sonne wegblasen, sodass manchmal ein langer, heller Schweif entsteht. Außerdem bewirken die Sonnenstrahlung und der Sonnenwind eine Ionisierung der Gase im Kometenschweif, die ihn zum Leuchten bringt.

Im Zusammenhang mit dem CTA-Algorithmus können wir uns jede Lösung als Kometenschweifteilchen vorstellen, die sich im Lösungsraum bewegen. Der Kometenkern stellt die beste Lösung dar, und die Teilchen im Schweif sind Ableitungen der Lösung, die vom Kern ausgeht. Diese Darstellung ermöglicht es dem Algorithmus, den Lösungsraum zu „lernen“ und sich an seine Merkmale anzupassen.


2. Implementierung des Algorithmus

Sehen wir uns die Bewegung des Kometen und seines Schweifs, die Schlüsselelemente in diesem Algorithmus sind, sowie die Rolle der Sonne bei diesen Prozessen genauer an.

Kometenbewegung:

  • Der Komet bewegt sich auf einer elliptischen Umlaufbahn um die Sonne.
  • Wenn sich ein Komet der Sonne nähert, beginnt er Gas und Staub auszustoßen und bildet einen Kometenschweif.
  • Die Bewegung des Kometen wird durch die Anziehungskraft der Sonne und die Abstoßung durch den Sonnenwind und die Sonnenstrahlung bestimmt.
  • Der Komet bewegt sich auf seiner Umlaufbahn, und sein Schweif ist immer in die der Sonne entgegengesetzte Richtung gerichtet.

Bewegung des Kometenschweifs:

  • Der Gasschweif des Kometen besteht aus ionisierten Gasen, die durch den Sonnenwind aus dem Kometenkern „herausgeschleudert“ werden.
  • Der Sonnenwind ist ein Strom von geladenen Teilchen, der von der Sonne ausgeht. Er „bläst“ den Gasschweif des Kometen weg und lenkt ihn in die entgegengesetzte Richtung zur Sonne.
  • Der Staubschweif eines Kometen besteht aus größeren Partikeln, die durch die Sonneneinstrahlung aus dem Kometenkern „herausgeschleudert“ werden.
  • Die Sonnenstrahlung übt Druck auf die Staubteilchen aus und lenkt sie leicht von der Bewegungsrichtung des Kometen ab, wodurch ein gekrümmter Staubschweif entsteht.

Die Rolle der Sonne:

  • Die Sonne ist das zentrale Objekt, um das sich der Komet auf seiner Umlaufbahn bewegt.
  • Die Anziehungskraft der Sonne bestimmt die Bewegung des Kometen auf einer elliptischen Umlaufbahn.
  • Der Sonnenwind und die Sonnenstrahlung „formen“ den Schweif des Kometen und lenken ihn in die entgegengesetzte Richtung zur Sonne.

    Kometen

    Abbildung 1. Form und Größe des Kometen im Zusammenhang mit dem CTA-Algorithmus als Funktion der Entfernung zum Stern (beste globale Lösung)

    Abbildung 1 veranschaulicht die Eigenschaften von Kometen in dem Algorithmus. Jeder Komet hat seine eigene eindeutige Nummer, die seinem Index in der Matrix entspricht. Die Abbildung zeigt die bedingten Bahnen der Kometen relativ zum Stern. Mit zunehmender Entfernung vom Stern verlängert sich der Schweif des Kometen und nimmt eine annähernd kugelförmige Gestalt an. Gleichzeitig wird die Wolke der Schweifteilchen relativ zum Kometenkern weniger stark verschoben. Je näher der Komet dem Stern ist, desto kleiner und länglicher wird der Schweifwahrscheinlichkeitsbereich.


    Der Komet Nummer 1 kam der Sonne zu nahe und verdampfte. In dem Algorithmus findet die Zerstörung des Kometen jedoch nicht wirklich statt. Stattdessen setzt sich die Bildung einer Schweifwolke mit einem Zentrum fort, das dem Zentrum des Sterns entspricht. Das heißt, je kleiner die Wolke des Schweifs ist, desto intensiver erfolgt die Verfeinerung der Lösung im Bereich des Kometen. Umgekehrt wird der Suchraum umso intensiver erkundet, je größer der Schweif ist. In diesem Fall sind die Achsen der Ellipsen aller Kometen immer vom Stern weggerichtet, d.h. weg von der aktuell besten globalen Lösung.

    Die Logik des Algorithmus erlaubt es uns, die Ausdehnungskoeffizienten der Kometenwolken sowohl in Richtung der Ausdehnung mit der Entfernung vom Stern als auch in Richtung der Abnahme zu regulieren. Es ist auch möglich, den Grad der Abflachung der Ellipsen in Abhängigkeit vom Radius der Kometenbahn anzupassen. Wir können den Schweif des Kometen sogar nicht vom Stern weg, sondern auf den Stern hin ausrichten (falls gewünscht).

    Abbildung 1 zeigt auch den Zeitpunkt der bedingten Wanderung des Kometen Nummer 2 auf eine neue Umlaufbahn (eingekreist Nummer 2). Dies geschieht durch den Austausch von Materie zwischen den Kernen zweier Kometen. In der Abbildung leiht sich der Komet 2 Materie vom Kometen 4. Wenn im Prozess des Materieaustauschs zwischen Kometen eine bessere Lösung gefunden wird, bewegt sich der entsprechende Komet (dessen Materie sich zu diesem Zeitpunkt gebildet hat) auf eine neue Umlaufbahn.

    Die Größe des Kometenschweifs und seine Verschiebung gegenüber dem Kern in Abhängigkeit von der Entfernung zum Stern lassen sich bedingt nach einem linearen Gesetz berechnen. In diesem Fall entspricht der maximale Abstand von 1 dem Bereich der minimalen und maximalen Werte für die entsprechende optimierte Koordinate des Problems. Mit diesem Ansatz lässt sich die Veränderung der Parameter des Kometenschweifs in Abhängigkeit von der Entfernung zum Stern auf einfache und klare Weise beschreiben.

    Diagramm

    Bild 2. Diagramme der Abhängigkeit des Verhältnisses der Kometenschweifverschiebung (violett) und der Schweifgröße (grün) von der Entfernung zum Stern

    Wir haben also die Gesetze der Veränderung von Form und Größe der Teilchenwolke für Kometen entwickelt, sodass wir die Schlussfolgerungen über die möglichen Eigenschaften des Algorithmus zusammenfassen können. Die wichtigsten Eigenschaften des vom Kometenschweif inspirierten Algorithmus, der die Richtung des Schweifs von der Sonne (globales Optimum) und die Suche sowohl nach den besten als auch nach den weniger optimalen Lösungen berücksichtigt, können wie folgt beschrieben werden:

    1. Verdunstung und Entwicklung von Lösungen. Der Algorithmus kann einen Prozess der Verdunstung und Evolution von Lösungen nutzen, bei dem sowohl die besten als auch die weniger optimalen Lösungsbereiche erkundet werden können.
    2. Multivarianz. Der Algorithmus kann bestrebt sein, eine Vielzahl von Lösungsoptionen zu generieren, die unterschiedliche Optimalitätsstufen widerspiegeln, ähnlich wie die Vielfalt der Zusammensetzung eines Kometenschweifs.
    3. Anpassungsfähigkeit an externe Faktoren. Da der Komet auf die Sonneneinstrahlung reagiert, kann der Algorithmus an Veränderungen der Umgebung oder der Zielfunktion angepasst werden.
    4. Suche nach dem globalen Optimum. Die Richtung des Schweifs von der Sonne weg könnte den Wunsch des Algorithmus symbolisieren, ein globales Optimum zu finden, während gleichzeitig weniger optimale Lösungen berücksichtigt werden, um eine vorzeitige Konvergenz zu lokalen Optima zu vermeiden.

    Entwerfen wir eine Skizze des Algorithmus in Pseudocode:

    1. Erzeuge Kometenkerne nach dem Zufallsprinzip.
    2. Aus Kometenkernen entstehen ihre Schweife - Teilchen mit einer Normalverteilung mit dem Kern in der Mitte.
    3. Berechne die Fitness der Kometenpartikel.
    4. Aktualisiere die globale Lösung.
    5. Weise das beste Teilchen des entsprechenden Kometen als seinen Kern zu.
    6. Gehe für jede Koordinate der Kometenpartikel wie folgt vor:
       Mit einer Wahrscheinlichkeit von 0,6, entweder:
          Erstelle Teilchen mit einer Normalverteilung mit einem Kometenkern in der Mitte.
       Oder:
          Erstelle ein Kometenpartikel mit den Koordinaten der Kerne von zwei zufällig ausgewählten Kometen.
    7. Aktualisiere die globale Lösung.
    8. Weise das beste Teilchen des entsprechenden Kometen als seinen Kern zu.
    9. Wiederhole den Vorgang ab 6, bis das Stoppkriterium erfüllt ist.

    Für den CTA-Algorithmus muss keine spezielle Struktur geschrieben werden. Die Grundstruktur des Agenten, die für den Austausch von Entscheidungen zwischen dem Algorithmus und dem ausführenden Programm verwendet wird, reicht aus, um Kometen und ihre Teilchen zu beschreiben. Erinnern wir uns daran, wie diese Struktur aussieht.

    Die Struktur S_AO_Agent enthält zwei Felder:

    • c[] - das Array speichert die Koordinaten des Agenten im Lösungsraum.
    • f - Fitness des Agenten, die zur Bewertung der Lösungsqualität verwendet wird.

    Im Zusammenhang mit dem CTA-Algorithmus werden wir diese Struktur verwenden, um sowohl die Kometen selbst als auch die Partikel ihrer Schweife zu beschreiben.

    //——————————————————————————————————————————————————————————————————————————————
struct S_AO_Agent
{
    double c []; //coordinates
    double f;    //fitness
};
//——————————————————————————————————————————————————————————————————————————————

    Definieren wir die Klasse C_AO_CTA, die von der Klasse C_AO abgeleitet ist.

    • C_AO_CTA () - der Konstruktor initialisiert das Klassenobjekt mit vordefinierten Werten. Er legt auch einige Parameter des Algorithmus fest, wie z. B. die Populationsgröße (popSize), die Anzahl der Kometen (cometsNumb), den Schweiflängenkoeffizienten (tailLengthKo), die maximalen und minimalen Verschiebungskoeffizienten (maxShiftCoef und minShiftCoef) sowie die maximalen und minimalen Größenkoeffizienten (maxSizeCoef und minSizeCoef).
    • SetParams() setzt die Algorithmusparameter auf der Grundlage der Werte im Array params.
    • Init() initialisiert den Algorithmus mit den angegebenen Suchbereichen und der Anzahl der Epochen.
    • Die Methoden Moving() und Revision() implementieren die Hauptlogik des Algorithmus.

    Das Feld comets[] ist ein Array von Objekten des Typs S_AO_Agent, die Kometen im Algorithmus darstellen.

    Die privaten Felder tailLength[], maxSpaceDistance[] und partNumber werden für den internen Betrieb des Algorithmus verwendet.

    //——————————————————————————————————————————————————————————————————————————————
class C_AO_CTA : public C_AO
{
  public: //--------------------------------------------------------------------
  ~C_AO_CTA () { }

  C_AO_CTA ()
  {
    ao_name = "CTA";
    ao_desc = "Comet Tail Algorithm";
    ao_link = "https://www.mql5.com/ru/articles/14841";

    popSize      = 50;   //population size
    cometsNumb   = 5;    //number of comets
    tailLengthKo = 0.2;  //tail length coefficient
    maxShiftCoef = 0.9;
    minShiftCoef = 0.5;
    maxSizeCoef  = 0.1;
    minSizeCoef  = 1.5;

    ArrayResize (params, 7);

    params [0].name = "popSize";       params [0].val = popSize;
    params [1].name = "cometsNumb";    params [1].val = cometsNumb;
    params [2].name = "tailLengthKo";  params [2].val = tailLengthKo;
    params [3].name = "maxShiftCoef";  params [3].val = maxShiftCoef;
    params [4].name = "minShiftCoef";  params [4].val = minShiftCoef;
    params [5].name = "maxSizeCoef";   params [5].val = maxSizeCoef;
    params [6].name = "minSizeCoef";   params [6].val = minSizeCoef;
  }

  void SetParams ()
  {
    popSize      = (int)params [0].val;
    cometsNumb   = (int)params [1].val;
    tailLengthKo = params      [2].val;
    maxShiftCoef = params      [3].val;
    minShiftCoef = params      [4].val;
    maxSizeCoef  = params      [5].val;
    minSizeCoef  = params      [6].val;
  }

  bool Init (const double &rangeMinP  [], //minimum search range
             const double &rangeMaxP  [], //maximum search range
             const double &rangeStepP [], //step search
             const int     epochsP = 0);  //number of epochs

  void Moving   ();
  void Revision ();
  void Injection (const int popPos, const int coordPos, const double value);

  //----------------------------------------------------------------------------
  int    cometsNumb;    //number of comets
  double tailLengthKo;  //tail length coefficient
  double maxShiftCoef;  //maximum shift coefficient
  double minShiftCoef;  //minimum shift coefficient
  double maxSizeCoef;   //maximum size coefficient
  double minSizeCoef;   //minimum size coefficient

  S_AO_Agent comets [];

  private: //-------------------------------------------------------------------
  int    epochs;
  int    epochNow;
  double tailLength       [];
  double maxSpaceDistance []; //maximum distance in space
  int    partNumber; //number of particles
};
//——————————————————————————————————————————————————————————————————————————————

    Wir definieren die Methode Init in der Klasse C_AO_CTA. Diese Methode initialisiert den Algorithmus mit den angegebenen Suchbereichen und der Anzahl der Epochen. Beschreibung der einzelnen Schritte:

    1. if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; - der Code ruft die Methode StandardInit mit den angegebenen Suchbereichen auf. Wenn StandardInit „false“ zurückgibt, gibt die Init-Methode ebenfalls sofort „false“ zurück.

    2. ArrayResize (comets, cometsNumb); - ändert die Größe des Arrays comets entsprechend der Anzahl der Kometen.

    3. Die Koordinaten und der Wert der Fitnessfunktion werden für jeden Kometen innerhalb der „for“-Schleife initialisiert.

    4. ArrayResize (tailLength, coords); ArrayResize (maxSpaceDistance, coords); - ändert die Größe der Arrays tailLength und maxSpaceDistance entsprechend der Anzahl der Koordinaten.

    5. In der folgenden „for“-Schleife werden für jede Koordinate der maximale Abstand im Raum und die Schweiflänge berechnet.

    6. partNumber = popSize / cometsNumb; - Berechnung der Anzahl der Partikel im Schweif jedes Kometen.

    //——————————————————————————————————————————————————————————————————————————————
bool C_AO_CTA::Init (const double &rangeMinP [], //minimum search range
                     const double &rangeMaxP  [], //maximum search range
                     const double &rangeStepP [], //step search
                     const int     epochsP = 0)   //number of epochs
{
  if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false;

  //----------------------------------------------------------------------------
  epochs   = epochsP;
  epochNow = 0;

  ArrayResize (comets, cometsNumb);
  for (int i = 0; i < cometsNumb; i++)
  {
    ArrayResize (comets [i].c, coords);
    comets [i].f = -DBL_MAX;
  }

  ArrayResize (tailLength,       coords);
  ArrayResize (maxSpaceDistance, coords);

  for (int i = 0; i < coords; i++)
  {
    maxSpaceDistance [i] = rangeMax [i] - rangeMin [i];
    tailLength       [i] = maxSpaceDistance [i] * tailLengthKo;
  }

  partNumber = popSize / cometsNumb;

  return true;
}
//——————————————————————————————————————————————————————————————————————————————

    Die Bildung von Partikeln in Kometenschweifen erfolgt in der Methode Moving() der Klasse C_AO_CTA. Die wichtigsten Schritte der Methode:

    1. Die Funktion beginnt mit der Inkrementierung des Epochenzählers epochNow und der Initialisierung der lokalen Variablen cnt, min und max.
    2. Wenn revision „false“ ist, werden die Kometenkoordinaten innerhalb der angegebenen Bereiche rangeMin und rangeMax initialisiert. Anschließend werden um jeden Kometen herum Partikel (Agenten) unter Verwendung der Gauß-Verteilung innerhalb des durch tailLength festgelegten Bereichs erzeugt.
    3. Wenn die Revision „true“ ist, wird die Position der Partikel (Agenten) aktualisiert. Die Koeffizienten coefTail und coefSize werden für jedes Partikel berechnet. Sie definieren die Verschiebung und Größe des Kometenschweifs in Abhängigkeit von der Entfernung zum zentralen Punkt cB. Diese Koeffizienten werden verwendet, um die neue Position des Teilchens innerhalb eines durch die Schweiflänge begrenzten Bereichs zu bestimmen.
    4. Wenn die Wahrscheinlichkeit u.RNDprobab() kleiner als 0,6 ist, wird die neue Position des Partikels anhand der Gauß-Verteilung berechnet. Andernfalls wird die neue Position des Teilchens als Linearkombination der Koordinaten der Kerne von zwei anderen zufällig ausgewählten Kometen berechnet.
    5. In allen Fällen sind die neuen Koordinaten des Partikels auf die Werte rangeMin und rangeMax begrenzt und werden mit dem Schritt rangeStep diskretisiert.

    Die allgemeine Idee dieser Methode besteht darin, die Bewegung und das Verhalten von Kometen in einem CTA-Algorithmus zu modellieren, wobei die Partikel (Agenten) den Schweif des Kometen darstellen und ihre Koordinaten und Schweifgröße von der Entfernung zur besten globalen Lösung (der Sonne) abhängen. 

    //——————————————————————————————————————————————————————————————————————————————
void C_AO_CTA::Moving ()
{
  epochNow++;
  int    cnt = 0;
  double min = 0.0;
  double max = 0.0;

  //----------------------------------------------------------------------------
  if (!revision)
  {
    for (int i = 0; i < cometsNumb; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        comets [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]);
        comets [i].c [c] = u.SeInDiSp  (comets [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      }
    }

    for (int i = 0; i < cometsNumb; i++)
    {
      for (int p = 0; p < partNumber; p++)
      {
        for (int c = 0; c < coords; c++)
        {
          min = comets [i].c [c] - tailLength [c] * 0.5; if (min < rangeMin [c]) min = rangeMin [c];
          max = comets [i].c [c] + tailLength [c] * 0.5; if (max > rangeMax [c]) max = rangeMax [c];

          a [cnt].c [c] = u.GaussDistribution (comets [i].c [c], min, max, 1);
          a [cnt].c [c] = u.SeInDiSp  (a [cnt].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
        }

        cnt++;
      }
    }

    revision = true;
    return;
  }

  //----------------------------------------------------------------------------
  cnt             = 0;
  double coefTail = 0.0;
  double coefSize = 0.0;

  for (int i = 0; i < cometsNumb; i++)
  {
    for (int p = 0; p < partNumber; p++)
    {
      for (int c = 0; c < coords; c++)
      {
        if (u.RNDprobab () < 0.6)
        {
          coefTail = fabs (comets [i].c [c] - cB [c]) / maxSpaceDistance [c];
          coefSize = coefTail;

          //(1-x)*0.9+x*0.5
          coefTail = (1 - coefTail) * maxShiftCoef + coefTail * minShiftCoef;

          //(1-x)*0.1+x*0.9
          coefSize = (1 - coefSize) * maxSizeCoef + coefSize * minSizeCoef;

          if (cB [c] * Dir > comets [i].c [c] * Dir)
          {
            min = comets [i].c [c] - tailLength [c] * coefTail         * coefSize;
            max = comets [i].c [c] + tailLength [c] * (1.0 - coefTail) * coefSize;
          }
          if (cB [c] * Dir < comets [i].c [c] * Dir)
          {
            min = comets [i].c [c] - tailLength [c] * (1.0 - coefTail) * coefSize;
            max = comets [i].c [c] + tailLength [c] * (coefTail)*coefSize;
          }
          if (cB [c] == comets [i].c [c])
          {
            min = comets [i].c [c] - tailLength [c] * 0.1;
            max = comets [i].c [c] + tailLength [c] * 0.1;
          }

          if (min < rangeMin [c]) min = rangeMin [c];
          if (max > rangeMax [c]) max = rangeMax [c];

          a [cnt].c [c] = u.GaussDistribution (comets [i].c [c], min, max, Power);
          a [cnt].c [c] = u.SeInDiSp  (a [cnt].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
        }
        else
        {
          int    r   = 0;
          int    r1  = 0;
          int    r2  = 0;

          do
          {
            r = u.RNDminusOne (cometsNumb);
            r1 = r;
          }
          while (r1 == i);

          do
          {
            r = u.RNDminusOne (cometsNumb);
            r2 = r;
          }
          while (r2 == i || r2 == r1);

          a [cnt].c [c] = comets [r1].c [c] + 0.1 * (comets [r2].c [c] - comets [i].c [c]) * u.RNDprobab();
          a [cnt].c [c] = u.SeInDiSp (a [cnt].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
        }
      }

      cnt++;
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

    Als Nächstes implementieren wir die Methode Revision() der Klasse C_AO_CTA, die für die Revision der Position von Kometen im Comet Tail Algorithm (CTA) verantwortlich ist.

    Die wichtigsten Schritte der Methode:

    1. Die Suche nach der besten Lösung in einer Population:

    • Die Methode durchläuft alle Lösungen in der Population popSize und findet eine Lösung mit dem besten Wert der Zielfunktion fB.
    • Wird eine bessere Lösung gefunden, so wird deren Position a[ind].c in den Vektor cB kopiert, in dem die beste bekannte Lösung gespeichert ist.

    2. Aktualisierung der Kometenposition:

    • Die Methode bewegt sich entlang aller cometsNumb Kometen und sucht für jeden Kometen die beste Lösung unter den Partikeln, die mit diesem partNumber Kometen verbunden sind.
    • Wenn die beste Lösung für einen Kometen gefunden wird, wird die Position comets[i].c dieses Kometen auf die Position der besten gefundenen Lösung a[ind].c aktualisiert.

    Mit dieser Methode wird ein wichtiger Schritt des CTA-Algorithmus umgesetzt, bei dem die Positionen der Kometen auf der Grundlage der besten in ihren Schweifen gefundenen Lösungen korrigiert werden. Dadurch kann die Suche auf Bereiche mit höheren Zielfunktionswerten gelenkt werden.

    //——————————————————————————————————————————————————————————————————————————————
void C_AO_CTA::Revision ()
{
  int ind = -1;

  for (int i = 0; i < popSize; i++)
  {
    if (a [i].f > fB)
    {
      fB = a [i].f;
      ind = i;
    }
  }

  if (ind != -1) ArrayCopy (cB, a [ind].c, 0, 0, WHOLE_ARRAY);

  //set a new kernel------------------------------------------------------------
  int cnt = 0;

  for (int i = 0; i < cometsNumb; i++)
  {
    ind = -1;

    for (int p = 0; p < partNumber;  p++)
    {
      if (a [cnt].f > comets [i].f)
      {
        comets [i].f = a [cnt].f;
        ind = cnt;
      }

      cnt++;
    }

    if (ind != -1) ArrayCopy (comets [i].c, a [ind].c, 0, 0, WHOLE_ARRAY);
  }
}
//——————————————————————————————————————————————————————————————————————————————


    3. Testergebnisse

    Testergebnisse von CTA:

    CTA|Comet Tail Algorithm|80.0|40.0|4.0|-1.0|0.2|1.0|0.5|0.1|15.0|
    =============================
    5 Hilly's; Func runs: 10000; result: 0.9534613588697962
    25 Hilly's; Func runs: 10000; result: 0.863192334000326
    500 Hilly's; Func runs: 10000; result: 0.27769783965091077
    =============================
    5 Forest's; Func runs: 10000; result: 0.997942251272262
    25 Forest's; Func runs: 10000; result: 0.857403562283056
    500 Forest's; Func runs: 10000; result: 0.33949224947400775
    =============================
    5 Megacity's; Func runs: 10000; result: 0.8876923076923078
    25 Megacity's; Func runs: 10000; result: 0.5643076923076924
    500 Megacity's; Func runs: 10000; result: 0.10512307692307787
    =============================
    All score: 5.84631 (64.96%)

    Auf der Grundlage der Tests können die folgenden Schlussfolgerungen über den CTA-Betrieb gezogen werden:

    Die Gesamtpunktzahl des Algorithmus beträgt 5,84631, was 64,96 % der maximal möglichen Punktzahl entspricht. Dies deutet auf eine hervorragende Leistung des CTA-Algorithmus hin.

    Hilly

      CTA mit der Testfunktion Hilly

    Forest

      CTA mit der Testfunktion Forest

    Megacity

      CTA mit der Testfunktion Megacity

    Basierend auf den Testergebnissen belegt der CTA-Algorithmus einen respektablen Platz 3 in der Bewertungstabelle.

    # AO Beschreibung Hilly Hilly final Forest Forest final Megacity (discrete) Megacity final Final result % of MAX
    10 p (5 F) 50 p (25 F) 1000 p (500 F) 10 p (5 F) 50 p (25 F) 1000 p (500 F) 10 p (5 F) 50 p (25 F) 1000 p (500 F)
    1 BGA binärer genetischer Algorithmus 0.99992 0.99484 0.50483 2.49959 1.00000 0.99975 0.32054 2.32029 0.90667 0.96400 0.23035 2.10102 6.921 76.90
    2 (P+O)ES (P+O) Entwicklungsstrategien 0.99934 0.91895 0.56297 2.48127 1.00000 0.93522 0.39179 2.32701 0.83167 0.64433 0.21155 1.68755 6.496 72.18
    3 CTA Kometenschweif-Algorithmus 0.95346 0.86319 0.27770 2.09435 0.99794 0.85740 0.33949 2.19484 0.88769 0.56431 0.10512 1.55712 5.846 64.96
    4 SDSm stochastische Diffusionssuche M 0.93066 0.85445 0.39476 2.17988 0.99983 0.89244 0.19619 2.08846 0.72333 0.61100 0.10670 1.44103 5.709 63.44
    5 ESG Entwicklung der sozialen Gruppen 0.99906 0.79654 0.35056 2.14616 1.00000 0.82863 0.13102 1.95965 0.82333 0.55300 0.04725 1.42358 5.529 61.44
    6 SIA Simuliertes isotropes Abkühlen 0.95784 0.84264 0.41465 2.21513 0.98239 0.79586 0.20507 1.98332 0.68667 0.49300 0.09053 1.27020 5.469 60.76
    7 TSEA Schildkrötenpanzer-Evolutionsalgorithmus 0.96798 0.64480 0.29672 1.90949 0.99449 0.61981 0.22708 1.84139 0.69077 0.42646 0.13598 1.25322 5.004 55.60
    8 DE differentielle Evolution 0.95044 0.61674 0.30308 1.87026 0.95317 0.78896 0.16652 1.90865 0.78667 0.36033 0.02953 1.17653 4.955 55.06
    9 BSA Vogelschwarm-Algorithmus 0.90857 0.73661 0.25767 1.90285 0.90437 0.81619 0.16401 1.88457 0.61692 0.54154 0.10951 1.26797 5.055 56.17
    10 HS Harmoniesuche 0.86509 0.68782 0.32527 1.87818 0.99999 0.68002 0.09590 1.77592 0.62000 0.42267 0.05458 1.09725 4.751 52.79
    11 SSG Setzen, Säen und Wachsen 0.77839 0.64925 0.39543 1.82308 0.85973 0.62467 0.17429 1.65869 0.64667 0.44133 0.10598 1.19398 4.676 51.95
    12 (PO)ES (PO) Entwicklungsstrategien 0.79025 0.62647 0.42935 1.84606 0.87616 0.60943 0.19591 1.68151 0.59000 0.37933 0.11322 1.08255 4.610 51.22
    13 BSO Brainstorming-Optimierung 0.91301 0.56222 0.30047 1.77570 0.97162 0.57162 0.23449 1,77772 0.60462 0.27138 0.12011 0.99611 4.550 50.55
    14 WOAm Wal-Optimierungsalgorithmus M 0.84521 0.56298 0.26263 1.67081 0.93100 0.52278 0.16365 1.61743 0.66308 0.41138 0.11357 1.18803 4.476 49.74
    15 ACOm Ameisen-Kolonie-Optimierung M 0.88190 0.66127 0.30377 1.84693 0.85873 0.58680 0.15051 1.59604 0.59667 0.37333 0.02472 0.99472 4.438 49.31
    16 BFO-GA Optimierung der bakteriellen Futtersuche - ga 0.89150 0.55111 0.31529 1.75790 0.96982 0.39612 0.06305 1.42899 0.72667 0.27500 0.03525 1.03692 4.224 46.93
    17 MEC Evolutionäre Berechnung des Geistes 0.69533 0.53376 0.32661 1.55569 0.72464 0.33036 0.07198 1.12698 0.52500 0.22000 0.04198 0.78698 3.470 38.55
    18 IWO Optimierung mit invasiven Unkräutern 0.72679 0.52256 0.33123 1.58058 0.70756 0.33955 0.07484 1.12196 0.42333 0.23067 0.04617 0.70017 3.403 37.81
    19 Micro-AIS Künstliches Mikro-Immunsystem 0.79547 0.51922 0.30861 1.62330 0.72956 0.36879 0.09398 1.19233 0.37667 0.15867 0.02802 0.56335 3.379 37.54
    20 COAm Kuckuck-Optimierungsalgorithmus M 0.75820 0.48652 0.31369 1.55841 0.74054 0.28051 0.05599 1.07704 0.50500 0.17467 0.03380 0.71347 3.349 37.21
    21 SDOm Optimierung der Spiraldynamik M 0.74601 0.44623 0.29687 1.48912 0.70204 0.34678 0.10944 1.15826 0.42833 0.16767 0.03663 0.63263 3.280 36.44
    22 NMm Nelder-Mead-Verfahren M 0.73807 0.50598 0.31342 1.55747 0.63674 0.28302 0.08221 1.00197 0.44667 0.18667 0.04028 0.67362 3.233 35.92
    23 FAm Firefly-Algorithmus M 0.58634 0.47228 0.32276 1.38138 0.68467 0.37439 0.10908 1.16814 0.28667 0.16467 0.04722 0.49855 3.048 33.87
    24 GSA Algorithmus für die Schwerkraftsuche 0.64757 0.49197 0.30062 1.44016 0.53962 0.36353 0.09945 1.00260 0.32667 0.12200 0.01917 0.46783 2.911 32.34
    25 BFO Optimierung der bakteriellen Futtersuche 0.61171 0.43270 0.31318 1.35759 0.54410 0.21511 0.05676 0.81597 0.42167 0.13800 0.03195 0.59162 2.765 30.72
    26 ABC Künstliches Bienenvolk (Artificial Bee Colony, ABC) 0.63377 0.42402 0.30892 1.36671 0.55103 0.21874 0.05623 0.82600 0.34000 0.14200 0.03102 0.51302 2.706 30.06
    27 BA Fledermaus-Algorithmus 0.59761 0.45911 0.35242 1.40915 0.40321 0.19313 0.07175 0.66810 0.21000 0.10100 0.03517 0.34617 2.423 26.93
    28 SA simuliertes Abkühlen 0.55787 0.42177 0.31549 1.29513 0.34998 0.15259 0.05023 0.55280 0.31167 0.10033 0.02883 0.44083 2.289 25.43
    29 IWDm intelligente Wassertropfen M 0.54501 0.37897 0.30124 1.22522 0.46104 0.14704 0.04369 0.65177 0.25833 0.09700 0.02308 0.37842 2.255 25.06
    30 PSO Partikelschwarmoptimierung 0.59726 0.36923 0.29928 1.26577 0.37237 0.16324 0.07010 0.60572 0.25667 0.08000 0.02157 0.35823 2.230 24.77
    31 Gebote Boids-Algorithmus 0.43340 0.30581 0.25425 0.99346 0.35718 0.20160 0.15708 0.71586 0.27846 0.14277 0.09834 0.51957 2.229 24.77
    32 MA Affen-Algorithmus 0.59107 0.42681 0.31816 1.33604 0.31138 0.14069 0.06612 0.51819 0.22833 0.08567 0.02790 0.34190 2.196 24.40
    33 SFL schlurfender Froschsprung 0.53925 0.35816 0.29809 1.19551 0.37141 0.11427 0.04051 0.52618 0.27167 0.08667 0.02402 0.38235 2.104 23.38
    34 FSS Fischschulsuche 0.55669 0.39992 0.31172 1.26833 0.31009 0.11889 0.04569 0.47467 0.21167 0.07633 0.02488 0.31288 2.056 22.84
    35 RND zufällig 0.52033 0.36068 0.30133 1.18234 0.31335 0.11787 0.04354 0.47476 0.25333 0.07933 0.02382 0.35648 2.014 22.37
    36 GWO Grauer-Wolf-Optimierung 0.59169 0.36561 0.29595 1.25326 0.24499 0.09047 0.03612 0.37158 0.27667 0.08567 0.02170 0.38403 2.009 22.32
    37 CSS Suche geladener Systeme 0.44252 0.35454 0.35201 1.14907 0.24140 0.11345 0.06814 0.42299 0.18333 0.06300 0.02322 0.26955 1.842 20.46
    38 EM elektromagnetismusähnlicher Algorithmus 0.46250 0.34594 0.32285 1.13129 0.21245 0.09783 0.10057 0.41085 0.15667 0.06033 0.02712 0.24412 1.786 19.85


    Zusammenfassung

    Der betrachtete CTA-Algorithmus basiert auf dem Konzept der Kometenbewegung und weist eine Reihe von Merkmalen auf, die den physikalischen Gesetzen und der Entwicklung von Kometen widersprechen. Die Auswirkungen dieser Merkmale auf die Endergebnisse des Algorithmus sollten genauer untersucht werden.


    Einer der Widersprüche betrifft die Richtung des Kometenschweifs. Beim CTA-Algorithmus führt die Verwendung der Schweifrichtung zum Stern (Dir_P = -1) im Allgemeinen zu einer deutlichen Verbesserung der Leistung. Die Verwendung der Richtung des Sternschweifs verbessert jedoch auch die Fähigkeit des Algorithmus, den Raum zu erkunden. Optimierungsbegeisterte könnten die Verwendung eines dynamischen, von der aktuellen Epoche abhängigen Leitwertkoeffizienten in Betracht ziehen. Es ist erwähnenswert, dass die Richtung des Schweifes weg vom Stern eine bessere Konvergenz bei niedrigdimensionalen Problemen bietet, während die Richtung zum Stern hin bei hochdimensionalen Problemen effektiver ist.

    Eine weitere Kontroverse ist die Größe des Kometenschweifs. Beim CTA-Algorithmus wurde festgestellt, dass eine dynamische Änderung der Schweifgröße (Vergrößerung mit zunehmendem Abstand zum Stern) die Effizienz des Algorithmus verbessert. Dies widerspricht den Gesetzen der Physik, denn in Wirklichkeit nimmt die Größe des Kometenschweifs zu, wenn er sich der Sonne nähert. Eine solche dynamische Änderung der Schweifgröße ermöglicht es uns jedoch, den Bereich der Untersuchung des Lösungsraums um den Kometenkern in von der globalen Lösung entfernte Gebiete auszudehnen, wodurch sich die Chancen auf die Entdeckung vielversprechender Lösungen erhöhen und die Wahrscheinlichkeit, in lokalen Extremen stecken zu bleiben, verringert. Bei der Annäherung an den Stern nimmt der Schweif des Kometen ab, wodurch sich die Intensität der Lösungsverfeinerung erhöht.

    Der CTA-Algorithmus beinhaltet auch den Austausch von Informationen zwischen Kometen, ähnlich dem, was in der Natur passiert, wenn Kometen Partikel einfangen, die von anderen Kometen zurückgelassen wurden. Dies ist eine zusätzliche Funktion des Algorithmus zur Erkundung des Lösungsraums. Es wurde versucht, Methoden zur Erhöhung der Populationsvielfalt einzusetzen, indem koronale Massenauswürfe aus dem Stern modelliert wurden und die kombinatorischen Eigenschaften des Algorithmus ausgenutzt wurden, indem die Koordinaten einiger Kometen von anderen übernommen wurden.

    CTA (Comet Tail Algorithm) ist ein interessanter neuer Ansatz zur Optimierung, der das Konzept der Kometenbewegung nutzt. Der Algorithmus zeigt eine gute Konvergenz für verschiedene Arten von Funktionen (sowohl glatte als auch diskrete), ist sehr einfach zu implementieren (die Struktur des Algorithmus ist sehr einfach, was seine Software-Implementierung vereinfacht), erfordert keine großen Rechenressourcen (da er keine Sortierung der Lösungen und keine Berechnungen der Abstände zwischen allen Lösungen verwendet, was seine Anwendung bei einer Vielzahl von Problemen ermöglicht), zeigt eine geringe Streuung der Ergebnisse bei diskreten Funktionen (Stabilität und Reproduzierbarkeit der Ergebnisse bei der Arbeit mit diskreten Zielfunktionen, wie bei den meisten Problemen der Optimierung von Handelssystemen), aber gleichzeitig hat der Algorithmus viele externe Parameter (wie die Größe des Kometenschweifs, die Koeffizienten des Schweifs und der Richtungsverschiebung, etc.). Bei glatten Funktionen mit hoher Dimension liefert der Algorithmus möglicherweise nicht die besten Ergebnisse.

    Im Allgemeinen liegt die Besonderheit von CTA in der dynamischen Balance zwischen der Erkundung des Lösungsraums und der Verfeinerung des gefundenen globalen Optimums.

    Daher verwendet der CTA-Algorithmus eine Reihe von Vereinfachungen und Annahmen, die nicht vollständig mit den physikalischen Gesetzen der Kometenbewegung übereinstimmen. Diese Abweichungen von der Realität ermöglichen es uns jedoch, die Effizienz des Algorithmus bei der Lösung von Optimierungsproblemen zu erhöhen und gleichzeitig die Einfachheit der Implementierung beizubehalten.


    Tabelle

    Abb. 3. Die farblichen Abstufungen der Algorithmen nach relevanten Tests Ergebnisse größer oder gleich 0,99 sind weiß hervorgehoben

    Histogramm

    Abb. 4. Das Histogramm der Algorithmus-Testergebnisse (auf einer Skala von 0 bis 100, größer ist besser,

    wobei 100 das maximal mögliche theoretische Ergebnis ist; das Archiv enthält ein Skript zur Berechnung der Bewertungstabelle)


    CTA Vor- und Nachteile:

    Vorteile:

    1. Gute Konvergenz bei verschiedenen Arten von Funktionen.
    2. Einfache Umsetzung.
    3. Geringe Beanspruchung von Computerressourcen.
    4. Geringe Streuung der Ergebnisse bei diskreten Funktionen.

    Nachteile

    1. Viele externe Parameter.
    2. Schlechte Ergebnisse für glatte hochdimensionale Funktionen.


    Quellcodes

      Der Artikel wird von einem Archiv mit den aktuellen Versionen der Algorithmuscodes begleitet. Der Autor des Artikels übernimmt keine Verantwortung für die absolute Richtigkeit der Beschreibung der kanonischen Algorithmen. An vielen von ihnen wurden Änderungen vorgenommen, um die Suchmöglichkeiten zu verbessern. Die in den Artikeln dargelegten Schlussfolgerungen und Urteile beruhen auf den Ergebnissen der Versuche.

      Übersetzt aus dem Russischen von MetaQuotes Ltd.
      Originalartikel: https://www.mql5.com/ru/articles/14841

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

      Andere Artikel von diesem Autor

      Zur Diskussion im Händlerforum
      Die Übertragung der Trading-Signale in einem universalen Expert Advisor. Die Übertragung der Trading-Signale in einem universalen Expert Advisor.
      In diesem Artikel wurden die verschiedenen Möglichkeiten beschrieben, um die Trading-Signale von einem Signalmodul des universalen EAs zum Steuermodul der Positionen und Orders zu übertragen. Es wurden die seriellen und parallelen Interfaces betrachtet.
      Neuronale Netze leicht gemacht (Teil 88): Zeitreihen-Dense-Encoder (TiDE) Neuronale Netze leicht gemacht (Teil 88): Zeitreihen-Dense-Encoder (TiDE)
      In dem Bestreben, möglichst genaue Prognosen zu erhalten, verkomplizieren die Forscher häufig die Prognosemodelle. Dies wiederum führt zu höheren Kosten für Training und Wartung der Modelle. Ist eine solche Erhöhung immer gerechtfertigt? In diesem Artikel wird ein Algorithmus vorgestellt, der die Einfachheit und Schnelligkeit linearer Modelle nutzt und Ergebnisse liefert, die mit den besten Modellen mit einer komplexeren Architektur vergleichbar sind.
      Eine alternative Log-datei mit der Verwendung der HTML und CSS Eine alternative Log-datei mit der Verwendung der HTML und CSS
      In diesem Artikel werden wir eine sehr einfache, aber leistungsfähige Bibliothek zur Erstellung der HTML-Dateien schreiben, dabei lernen wir auch, wie man eine ihre Darstellung einstellen kann (nach seinem Geschmack) und sehen wir, wie man es leicht in seinem Expert Advisor oder Skript hinzufügen oder verwenden kann.
      Schildkrötenpanzer-Evolutionsalgorithmus (TSEA) Schildkrötenpanzer-Evolutionsalgorithmus (TSEA)
      Dies ist ein einzigartiger Optimierungsalgorithmus, der von der Evolution des Schildkrötenpanzers inspiriert wurde. Der TSEA-Algorithmus emuliert die allmähliche Bildung keratinisierter Hautbereiche, die optimale Lösungen für ein Problem darstellen. Die besten Lösungen werden „härter“ und befinden sich näher an der Außenfläche, während die weniger erfolgreichen Lösungen „weicher“ bleiben und sich im Inneren befinden. Der Algorithmus verwendet eine Gruppierung der Lösungen nach Qualität und Entfernung, wodurch weniger erfolgreiche Optionen erhalten bleiben und Flexibilität und Anpassungsfähigkeit gewährleistet werden.