Künstlicher Algenalgorithmus (AAA)

Inhalt

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

Einführung

Algen, einige der ältesten Organismen der Erde, spielen eine Schlüsselrolle in aquatischen Ökosystemen. Es gibt über 45.000 Algenarten, die sich in Farbe, Form, Größe und Lebensraum stark unterscheiden können. Sie sorgen für Leben im Wasser, da sie die Grundlage für die Ernährung vieler Tierarten sind, und sie produzieren durch Photosynthese auch Sauerstoff, was sie für die Erhaltung des Lebens auf dem Planeten wichtig macht. Diese lebenden Organismen können entweder ein- oder mehrzellig sein und bilden oft Kolonien, die als eine Einheit funktionieren.

Einzellige Algen können sich durch Mitose teilen, wobei neue Zellen entstehen, die miteinander verbunden bleiben und eine Kolonie bilden. Mehrzellige Algen können sich durch Sporen vermehren, die sich im Wasser ausbreiten und zu neuen Organismen keimen, die ebenfalls Kolonien bilden. Diese erstaunlichen Organismen zeigen, wie biologische Prozesse genutzt werden können, um innovative Lösungen für die mathematische Modellierung und Optimierung zu finden.

Der künstliche Algenalgorithmus (AAA), der 2015 von Uymaz, Tezel und Yel vorgeschlagen wurde, ist eine Kombination aus biologischem Naturphänomen und mathematischer Eleganz. Dieser metaheuristische Optimierungsalgorithmus wurde von der faszinierenden Welt der Mikroalgen inspiriert, deren koloniale Gewohnheiten und Anpassungsfähigkeiten als Grundlage für die Schaffung eines algorithmischen Optimierungsmodells dienten. Inspiriert von der Fähigkeit der Mikroalgen, sich auf eine Lichtquelle zuzubewegen, sich an wechselnde Umweltbedingungen anzupassen und sich durch Mitose zu vermehren, um die Photosynthese zu verbessern, wurde AAA entwickelt, um diese einzigartigen Eigenschaften mathematisch zu modellieren.

Der Algorithmus umfasst drei Schlüsselprozesse: spiralförmige Bewegung, evolutionärer Prozess und Anpassung. Die spiralförmige Bewegung simuliert die dreidimensionale Bewegung von Algen in einer Nährlösung und ermöglicht es ihnen, optimale Wachstumsbedingungen zu finden. Der Evolutionsprozess sorgt dafür, dass sich die Algenkolonien unter den am besten geeigneten Bedingungen vermehren, was ihre Entwicklung fördert und die Lösungen verbessert. Die Anpassung hilft weniger erfolgreichen Kolonien, sich der größten Kolonie anzunähern und so ihr Überleben und ihre weitere Entwicklung zu sichern.

Implementierung des Algorithmus

Der künstliche Algenalgorithmus (AAA) wurde entwickelt, um die Eigenschaften von Algen, wie ihre spiralförmige Bewegung, ihre Anpassung und ihren Evolutionsprozess, mathematisch zu modellieren. Jede Algenkolonie stellt einen möglichen Lösungsvorschlag für das Optimierungsproblem dar (und jede Zelle in der Kolonie ist eine eigene Koordinate), und diese Kolonien schließen sich zu einer Algenpopulation zusammen. Jede Kolonie ist durch ihre Größe gekennzeichnet, die die Qualität der präsentierten Lösung widerspiegelt.

Im Laufe der Evolution können sich Algenkolonien, die geeignetere Umweltbedingungen erreichen, entwickeln und wachsen. Kolonien, die keine geeigneten Bedingungen vorfinden, entwickeln sich nicht und sterben. Nach Abschluss der spiralförmigen Bewegung werden die Algenkolonien nach ihrer Größe geordnet. Eine zufällig ausgewählte Zelle der größten Kolonie wird in die gleiche Zelle der kleinsten Kolonie kopiert, womit der Evolutionsprozess abgeschlossen ist.

Algenkolonien führen spiralförmige Bewegungen im Wasser aus, um bessere Umweltbedingungen zu erreichen. Ihre Energie ist proportional zur Größe der Kolonie. Während der Bewegung verlieren sie Energie, aber wenn sie eine bessere Umgebung erreichen, stellen sie die Hälfte der verlorenen Energie wieder her. Die Energie einer Kolonie ist direkt proportional zur Nährstoffkonzentration, d. h. je mehr Energie eine Kolonie hat, desto höher ist ihre Bewegungsfrequenz.

Die Reibungskraft ist ein weiterer wichtiger Faktor, der die Bewegung im Wasser beeinflusst. Kolonien mit einer kleineren Oberfläche haben einen größeren Bewegungsspielraum, weil ihre Reibungsfläche kleiner ist. Kolonien, die bessere Bedingungen erreichen, haben aufgrund ihrer Größe eine größere Reibungsfläche, sodass die Kolonien ihre Bewegungen verlangsamen, was ihnen hilft, die Umgebung der gefundenen Lösung zu erkunden und ihre lokalen Suchmöglichkeiten zu erhöhen.

Die Anpassung findet statt, wenn Algenkolonien, die während der spiralförmigen Bewegung keine ausreichende Entwicklung erreicht haben, versuchen, die größte Kolonie zu imitieren. Die Kolonie mit dem höchsten Hungerwert durchläuft diesen Prozess. Zu Beginn der Optimierung ist der Hungerwert aller Kolonien gleich Null. Während der spiralförmigen Bewegung steigt der Hungerwert der Kolonien, die keine bessere Lösung gefunden haben, um eins. Nach der spiralförmigen Bewegung und dem evolutionären Prozess tritt die Kolonie mit dem höchsten Hungerwert in die Anpassungsphase ein. Der Anpassungsprozess findet jedoch nicht bei jeder Iteration statt. Zunächst wird ein Zufallswert zwischen 0 und 1 gewählt. Ist dieser Wert kleiner als der Anpassungsparameter, wird die Anpassung durchgeführt.

Gehen wir nun zum Schreiben des AAA-Pseudocodes über:

Initialisierung:
    Erstelle eine Population von Agenten
    Für jeden Agenten:
        Initialisiere eine zufällige Position im Suchraum
        Initialisiere die Parameter (Größe, Energie, Hunger usw.)

Hauptschleife:
    Bis das Stoppkriterium erreicht ist:
        Für jeden Agenten:
            Bewegung ausführen
            Bewerte die Fitnessfunktion
        
        Aktualisiere die beste gefundene Lösung
        
        Für jeden Agenten:
            Energie aktualisieren
            Größe aktualisieren
            Hunger aktualisieren
        
        Evolution durchführen
        Anpassung durchführen

Funktion der Bewegung:
    Für jeden Agenten:
        Wähle einen anderen Agenten über die Turnierauswahl
        Für jede Koordinate:
            Aktualisiere die Position des Agenten unter Verwendung der trigonometrischen Spiralbewegungsgleichung
            und das Reibungsverhältnis

Die Funktion EvolutionProcess:
    Finde den Agenten mit der kleinsten Größe
    Ersetze seine Koordinaten durch die Koordinaten eines zufällig ausgewählten Agenten

Die Funktion AdaptationProcess:
    Finde den Agenten mit dem größten Hunger
    Mit einer gewissen Wahrscheinlichkeit:
        Finde den Agenten mit der größten Größe
        Aktualisiere die Koordinaten des hungernden Agenten, um sie näher an die Koordinaten zu bringen
        und des großen Agenten
        setze die Parameter des hungernden Agenten zurück

Die Funktion EnergyCalculation:
    Berechne die Energie anhand der Koloniegröße und der Nährstoffkonzentration
    und der aktuelle Wachstumsrate

Die Funktion TournamentSelection:
    Wähle zwei zufällige Agenten
    Rückgabe des Agenten mit dem besten Wert der Fitnessfunktion

Führen wir die im Algorithmus verwendeten Gleichungen auf. Die Gleichungen 1-5 beziehen sich direkt auf die Implementierung der Grundlogik des Algorithmus.

1. Initialisierung der Population: Population = [[x1_1, x1_2, ..., x1_D], [x2_1, x2_2, ..., x2_D], [xN_1, xN_2, ..., xN_D]], mit xj_i  — i-te Zelle der j-ten Algenkolonie, D — Dimension der Kolonie und der Populationsgröße N.

2. Spiralförmige Bewegung: x'i_j = xi_j + α * cos (θ) * τ (Xi) * p; y'i_j = yi_j + α * sin (θ) * τ (Xi) * p; z'i_j = zi_j + r * v, mit (x'i_j, y'i_j, z'i_j) — neue Koordinaten der i-ten Kolonie, α, θ ∈ [0, 2π], p ∈ [-1, 1], r ∈ [-1, 1], v ∈ [-1, 1], τ (Xi) — Reibungsfläche der i-ten Kolonie.

3. Evolutionärer Prozess: biggest = max (Gi), m = zufällig ausgewählte Zelle, smallest.xm = biggest.xm

4. Anpassung: starving = max (Ai); starving.x = starving.x + (biggest.x - starving.x) * rand

5. Monod-Modell des Algenwachstums: μt = μtmax * St / (St + Kt), mit μt , der Wachstumsrate der Algen zu einem bestimmten Zeitpunkt t, μtmax der maximalen Wachstumsrate, St die Koloniegröße zu einem bestimmten Zeitpunkt t und der Halbsättigungskonstante Kt.

6. Reibungsfläche: τ (Xi) = 2π * (3√ (3*Gi) / (4π))^2, mit τ (Xi) der Reibungsfläche der i-ten Kolonie und Gi der Größe der i-ten Kolonie.

7. Die Kolonieauswahl für die Spiralbewegung: Die Turnierauswahl dient der Auswahl der Kolonie, die sich bewegen wird. Darauf werden wir weiter unten noch näher eingehen.

8. Auswahl von Zufallsdimensionen für die Spiralbewegung: p, r, v sind zufällig ausgewählte, voneinander abweichende Messindizes.

9. Auswahl einer benachbarten Kolonie für die Spiralbewegung: Xj ist eine Kolonie, die im Rahmen eines Turniers ausgewählt wurde und in die die Kolonie Xi eingefügt wird.

10. Anfangshunger aller Kolonien: Ai = 0 für alle i.

11. Erhöhter Hunger in Kolonien, die die Lösung nicht verbessert haben: Ai = Ai + 1, wenn die Kolonie keine bessere Lösung gefunden hat.

12. Auswahl einer Kolonie mit maximalem Hunger: starving = max (Ai).

13. Anpassungswahrscheinlichkeit: rand < Ap, wobei Ap ein Anpassungsparameter ist.

Die Gleichungen 6-13 beschreiben zusätzliche Details der Algorithmusimplementierung, wie die Berechnung der Reibungsfläche, die Auswahl der Kolonien für die Bewegung, das Management des Aushungerns von Kolonien und die Anpassungswahrscheinlichkeit.

Das Monod-Modell wird häufig verwendet, um das Wachstum und Verhalten von Populationen in biologischen Systemen zu beschreiben. Es basiert auf den Arbeiten von Jacques Monod, einem französischen Biochemiker, der die Wachstumskinetik von Mikroorganismen untersucht hat. Die Geschwindigkeit des Populationswachstums hängt von der Konzentration des Substrats (Nährstoffs) ab. Bei niedrigen Substratkonzentrationen ist die Wachstumsrate proportional zur Konzentration, und bei hohen Konzentrationen erreicht sie ihr Maximum. In Optimierungsalgorithmen wird das Monod-Modell verwendet, um das Wachstum und die Anpassung von Populationen in evolutionären Algorithmen zu modellieren. Während der Optimierung ändern sich die Populationsparameter in Abhängigkeit von den verfügbaren Ressourcen, was eine genauere Modellierung der realen biologischen Prozesse ermöglicht.

Ich möchte Ihre Aufmerksamkeit auf die Turnierauswahl für die Wahl einer Kolonie lenken. Diese Methode haben wir in den Algorithmen bisher nicht verwendet. Schreiben wir ein Skript und drucken wir die Ergebnisse aus, um die Verteilung der Auswahlwahrscheinlichkeiten der Individuen in der Population mit dieser Auswahlmethode deutlich zu sehen. Der blau hervorgehobene Codeabschnitt ist direkt an der Verteilungsbildung bei der Auswahl beteiligt.

input int      PopSize = 50;
input int      Count   = 1000000;
input int      BarWidth = 50; // Histogram width in characters

void OnStart()
{
  int pop[];
  ArrayResize(pop, PopSize);

  for(int i = 0; i < PopSize; i++) pop[i] = PopSize - i;

  Print("Original population:");
  ArrayPrint(pop);

  int tur[];
  ArrayResize(tur, PopSize);
  ArrayInitialize(tur, 0);

  int ind1 = 0, ind2 = 0;

  for(int i = 0; i < Count; i++)
  {
    ind1 = MathRand() % PopSize;
    ind2 = MathRand() % PopSize;

    if(pop[ind1] > pop[ind2]) tur[ind1]++;
    else                      tur[ind2]++;
  }

  Print("Probability distribution (in %):");

  double maxPercentage = 0;
  double percentages[];
  ArrayResize(percentages, PopSize);

  for(int i = 0; i < PopSize; i++)
  {
    percentages[i] = (double)tur[i] / Count * 100;
    if(percentages[i] > maxPercentage) maxPercentage = percentages[i];
  }

  for(int i = 0; i < PopSize; i++)
  {
    int barLength = (int)((percentages[i] / maxPercentage) * BarWidth);
    string bar = "";
    for(int j = 0; j < barLength; j++) bar += "|";

    PrintFormat("%2d: %5.2f%% %s", i, percentages[i], bar);
  }
}

Nachfolgend sehen Sie das Ergebnis der Ausführung eines Skripts zur Visualisierung der Wahrscheinlichkeitsverteilung der Auswahl jedes Individuums in der Population:

Ursprüngliche Population:
20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1
Wahrscheinlichkeitsverteilung (in %):
 0:  9.76% ||||||||||||||||||||||||||||||||||||||||||||||||||
 1:  9.24% |||||||||||||||||||||||||||||||||||||||||||||||
 2:  8.74% ||||||||||||||||||||||||||||||||||||||||||||
 3:  8.22% ||||||||||||||||||||||||||||||||||||||||||
 4:  7.77% |||||||||||||||||||||||||||||||||||||||
 5:  7.27% |||||||||||||||||||||||||||||||||||||
 6:  6.74% ||||||||||||||||||||||||||||||||||
 7:  6.26% ||||||||||||||||||||||||||||||||
 8:  5.78% |||||||||||||||||||||||||||||
 9:  5.25% ||||||||||||||||||||||||||
10:  4.75% ||||||||||||||||||||||||
11:  4.22% |||||||||||||||||||||
12:  3.73% |||||||||||||||||||
13:  3.25% ||||||||||||||||
14:  2.75% ||||||||||||||
15:  2.25% |||||||||||
16:  1.75% ||||||||
17:  1.25% ||||||
18:  0.77% |||
19:  0.25% |

Die Wahrscheinlichkeitsverteilung nimmt linear ab, sodass Kolonien mit höheren Chancen auf gute Lösungen ausgewählt werden können, aber auch weniger effiziente Optionen eine Chance haben, ausgewählt zu werden. Dieser Selektionsansatz hängt nicht von den absoluten Werten der Fitness der Individuen ab, was eine große Bandbreite an Lösungsvielfalt ermöglicht.

In früheren Artikeln haben wir bereits Gleichungen für die Änderung der Wahrscheinlichkeitsverteilung während der Auswahl betrachtet, allerdings mit der Möglichkeit, sowohl lineare als auch nicht-lineare Wahrscheinlichkeitsabnahmen zu liefern, und mit weniger Rechenaufwand (für die Turnierauswahl ist ein doppelter Aufruf der Funktion MathRand() erforderlich).

Abbildung 1. Beispiele für Gleichungen zur Veränderung der Form einer Wahrscheinlichkeitsverteilung, wobei x eine gleichmäßig verteilte Zufallszahl im Bereich [0,0, 1,0] ist

Nachdem wir nun alle Feinheiten des Algorithmus im Detail behandelt haben, können wir mit dem Schreiben des Codes selbst beginnen.

Beschreiben wir nun die Struktur S_AAA_Agent, die zur Simulation der Algenkolonie (Agent) im Algorithmus verwendet wird. Die Struktur enthält vier Felder:

• energy — das Energieniveau des Agenten.
• hunger — Hungerlevel des Agenten.
• size — Größe des Agenten (Höhe und Länge der Algen).
  
• friction — Reibungsverhältnis, das die Bewegung des Mittels beeinflusst.

Init — die Methode initialisiert die Strukturmitglieder mit Standardwerten. 

Die Struktur S_AAA_Agent ist also ein einfaches Agentenmodell mit grundlegenden Eigenschaften.

//——————————————————————————————————————————————————————————————————————————————
struct S_AAA_Agent
{
  double energy;
  int    hunger;
  double size;
  double friction;

  void Init ()
  {
    energy   = 1.0;
    hunger   = 0;
    size     = 1.0;
    friction = 0.0;
  }
};
//——————————————————————————————————————————————————————————————————————————————

Schreiben wir die Definition der Klasse C_AO_AAA, die von der Basisklasse C_AO geerbt wurde. Das bedeutet, dass sie alle Mitglieder und Methoden der Basisklasse erbt und diese erweitern oder außer Kraft setzen kann.

1. Im Klassenkonstruktor werden Werte für verschiedene Parameter im Zusammenhang mit dem Algorithmus festgelegt und auch initialisiert:

• popSize — Größe der Population.
• adaptationProbability — Anpassungswahrscheinlichkeit.
• energyLoss — Energieverlust.
• maxGrowthRate — maximale Wachstumsrate.
• halfSaturationConstant — Konstante für die halbe Absorption.

Alle diese Parameter werden in dem Array params gespeichert.

2. Die Methode SetParams aktualisiert die Werte der Algorithmusparameter aus dem Array params.

3. Die verfügbaren Optionen sind:

• Init () — Die Initialisierungsmethode akzeptiert Arrays für die minimalen und maximalen Parameterwerte sowie die Schritte und die Anzahl der Epochen.
• Moving () — Methode ist für das Verschieben oder Aktualisieren des Zustands von Agenten zuständig.
• Revision () — Methode zur Überprüfung oder Bewertung eines Zustands.
• EvolutionProcess (), AdaptationProcess (), CalculateEnergy (), TournamentSelection () — private Methoden sind für den Evolutionsprozess, die Anpassung, die Berechnung der Algenenergie bzw. die Turnierauswahl zuständig.
  

Felder der Klasse:

• adaptationProbability, energyLoss, maxGrowthRate, halfSaturationConstant — Variablen zur Speicherung von Parameterwerten.
• S_AAA_Agent agent [] — Array von Agenten.
  
• fMin, fMax — Fitnesswerte (Algengröße) für eine Population.

Die Klasse C_AO_AAA ist eine Struktur, die eine bequeme Verwaltung der Parameter und des Zustands der Agenten sowie die Integration in ein breiteres System auf der Grundlage der Vererbung von der Klasse C_AO ermöglicht.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_AAA : public C_AO
{
  public: //--------------------------------------------------------------------

  ~C_AO_AAA () { }

  C_AO_AAA ()
  {
    ao_name = "AAA";
    ao_desc = "Algae Adaptive Algorithm";
    ao_link = "https://www.mql5.com/en/articles/15565";

    popSize                = 200;
    adaptationProbability  = 0.2;
    energyLoss             = 0.05;
    maxGrowthRate          = 0.1;
    halfSaturationConstant = 1.0;

    ArrayResize (params, 5);

    params [0].name = "popSize";                params [0].val = popSize;
    params [1].name = "adaptationProbability";  params [1].val = adaptationProbability;
    params [2].name = "energyLoss";             params [2].val = energyLoss;
    params [3].name = "maxGrowthRate";          params [3].val = maxGrowthRate;
    params [4].name = "halfSaturationConstant"; params [4].val = halfSaturationConstant;
  }

  void SetParams ()
  {
    popSize                = (int)params [0].val;
    adaptationProbability  = params      [1].val;
    energyLoss             = params      [2].val;
    maxGrowthRate          = params      [3].val;
    halfSaturationConstant = params      [4].val;
  }

  bool Init (const double &rangeMinP  [],
             const double &rangeMaxP  [],
             const double &rangeStepP [],
             const int     epochsP = 0);

  void Moving   ();
  void Revision ();

  //----------------------------------------------------------------------------
  double adaptationProbability;
  double energyLoss;
  double maxGrowthRate;
  double halfSaturationConstant;

  S_AAA_Agent agent [];

  private: //-------------------------------------------------------------------
  void   EvolutionProcess    ();
  void   AdaptationProcess   ();
  double CalculateEnergy     (int index);
  int    TournamentSelection ();
  double fMin, fMax;
};
//——————————————————————————————————————————————————————————————————————————————

Schauen wir uns die folgende Methode Init der Klasse C_AO_AAA im Detail an:

• rangeMinP — Array der Mindestwerte für jeden Parameter.
• rangeMaxP — Array der Höchstwerte für jeden Parameter.
• rangeStepP — Array der Änderungsschritte für jeden Parameter.
• epochsP — Anzahl der Epochen (Standard — 0).

Felder der Methode:

1. Die Methode StandardInit führt eine Standardinitialisierung mit den übergebenen Parametern durch. 

2. Ändert die Größe des Agentenarrays auf popSize. So können wir ein Array für die Speicherung von Agenten vorbereiten.

3. Legt die Mindest- und Höchstwerte für die während des Betriebs verwendeten Funktionen fest.

4. Die Schleife durchläuft jeden Agenten und initialisiert ihn mit der Methode Init.

5. In der inneren Schleife werden die Koordinaten der einzelnen Agenten initialisiert:

• Zunächst wird die Koordinate c mit Hilfe der Methode RNDfromCI zufällig in den Bereich von rangeMin [c] bis rangeMax [c] gesetzt.
• Anschließend wird die Koordinate mit Hilfe der SeInDiSp geändert, die die Werte normalisiert.

Wenn alle Operationen erfolgreich waren, gibt die Methode true zurück. So initialisiert die Methode Init das Array der Agenten mit gegebenen Bereichen und Schritten für deren Koordinaten. Sie umfasst die Standardinitialisierung, die Festlegung der Grenzen für die Funktion und die zufällige Zuweisung von Koordinatenwerten.

//——————————————————————————————————————————————————————————————————————————————
bool C_AO_AAA::Init (const double &rangeMinP  [],
                     const double &rangeMaxP  [],
                     const double &rangeStepP [],
                     const int     epochsP = 0)
{
  if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false;

  ArrayResize (agent, popSize);

  fMin = -DBL_MAX;
  fMax =  DBL_MAX;

  for (int i = 0; i < popSize; i++)
  {
    agent [i].Init ();

    for (int c = 0; c < coords; c++)
    {
      a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]);
      a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }

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

Betrachten wir nun den Code der Methode Moving der Klasse C_AO_AAA. Allgemeine Struktur und Funktionalität:

1. Ist die Variable revision false, wird sie auf true gesetzt, und die Funktion wird beendet. Dies bedeutet, dass die grundlegende Logik der Methode Moving nicht bei der ersten Iteration ausgeführt wird.

2. Die Schleife durchläuft alle popSize Elemente der Population.

3. Die Auswahl des Turniers erfolgt mit der Funktion TournamentSelection, die den Index eines der Agenten (Algen) zur weiteren Verwendung zurückgibt.

4. Die innere Schleife durchläuft jede Koordinate (die durch die Variable coords angegebene Dimension des Raums).

5. Es werden drei Zufallswerte generiert: die Winkel α und β und der Wert ρ im Bereich von -1 bis 1 mit der Methode u.RNDfromCI.

6. Je nach dem Wert von variant (der zwischen 0 und 2 variiert) werden die Koordinaten a [i].c [c] aktualisiert:

• Ist variant 0, wird der Kosinus des Winkels α verwendet.
• Ist variant 1, wird der Sinus des Winkels β verwendet.
• Ist variant 2, wird der Wert ρ verwendet.

Die Verwendung der Variablen variant ermöglicht es, die dreidimensionale spiralförmige Bewegung der Algen im mehrdimensionalen Raum zu simulieren. Bei der Koordinatenaktualisierung wird die als agent[i].friction angegebene Reibung berücksichtigt.

7. Die Koordinaten a [i].c [c] werden mit der Funktion u.SeInDiSp begrenzt, die einen Wert innerhalb eines bestimmten Bereichs und mit einem bestimmten Schritt festlegt.

Die Funktion Moving implementiert den Prozess durch zufällige Änderungen der Koordinaten der Agenten auf der Grundlage ihres aktuellen Zustands und des Zustands der anderen Agenten. Mit Hilfe von Reibung und Zufallswerten können wir eine Dynamik erzeugen, die das Verhalten der Agenten im Suchraum simuliert. Der Code enthält Mechanismen, die verhindern, dass die angegebenen Bereiche überschritten werden, was für die Beibehaltung gültiger Koordinatenwerte wichtig ist.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_AAA::Moving ()
{
  //----------------------------------------------------------------------------
  if (!revision)
  {
    revision = true;
    return;
  }

  //----------------------------------------------------------------------------
  for (int i = 0; i < popSize; i++)
  {
    int variant = 0;

    int j = TournamentSelection ();

    for (int c = 0; c < coords; c++)
    {
      double α = u.RNDfromCI (0.0, 2 * M_PI);
      double β = u.RNDfromCI (0.0, 2 * M_PI);
      double ρ = u.RNDfromCI (-1.0, 1.0);

      if (variant == 0) a [i].c [c] += (a [j].c [c] - a [i].c [c]) * agent [i].friction * MathCos (α);
      if (variant == 1) a [i].c [c] += (a [j].c [c] - a [i].c [c]) * agent [i].friction * MathSin (β);
      if (variant == 2) a [i].c [c] += (a [j].c [c] - a [i].c [c]) * agent [i].friction * ρ;

      variant++;

      if (variant > 2) variant = 0;

      a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Nach der Methode Moving gehen Sie zur Methode Revision der Klasse C_AO_AAA über. Diese Methode ist für die Aktualisierung des Zustands der Agenten in einer Population auf der Grundlage ihrer Eigenschaften und Interaktionen zuständig. Allgemeine Struktur:

1. Die Variable ind wird mit dem Wert -1 initialisiert. Er wird verwendet, um den Index des Agenten mit dem besten Funktionswert zu speichern.

2. Die Schleife durchläuft alle Agenten in der Population mit der Größe popSize. Innerhalb der Schleife: wenn der Wert der Funktion a [i].f den aktuellen Höchstwert fB überschreitet, 

• wird der fB-Maximalwert aktualisiert,
• wird der Index des Agenten mit dem besten Wert in der Variablen ind gespeichert,
• wird agent [i].size, die Größe des Agenten, entsprechend dem Wert der Fitnessfunktion a [i].f aktualisiert und
• die minimalen fMin- und maximalen fMax-Werte der Fitnessfunktion für den aktuellen Agenten werden aktualisiert.

3. Wurde ein Agent mit dem maximalen Fitnesswert f gefunden, werden seine Koordinaten mit Hilfe der Funktion ArrayCopy in das Array cB kopiert.

4. Aktualisierung der Energie und anderer Agentenparameter:

• Seine Energie wird mit der Funktion CalculateEnergy berechnet,
• die Reibung wird berechnet und durch fMin und fMax normiert,
• die Energie des Agenten wird durch energyLoss verringert,
• ist die neue Energie größer als die aktuelle, erhöht sich die Energie um die Hälfte des Verlustes, und der Hunger des Agenten wird zurückgesetzt, andernfalls steigt das Hungergefühl und
• ein Wachstumsfaktor wird auf der Grundlage der aktuellen Größe des Agenten und der Sättigung berechnet, und die Größe des Agenten wird aktualisiert.

5. Aufruf der Prozesse: Am Ende der Funktion werden die Methoden EvolutionProcess und AdaptationProcess aufgerufen. Die Methoden sind für die weitere Entwicklung und Anpassung der Agenten auf der Grundlage ihres aktuellen Zustands verantwortlich.

Im Allgemeinen ist die Revisionsfunktion dafür verantwortlich, den Zustand der Agenten in einer Population auf der Grundlage ihrer Merkmale und Interaktionen zu aktualisieren. Es umfasst Analysen sowie die Aktualisierung und den Aufruf zusätzlicher Prozesse, die eine Modellierung der Populationsdynamik ermöglichen.

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

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

      ind = i;
    }

    agent [i].size = a [i].f;

    if (a [i].f < fMin) fMin = a [i].f;
    if (a [i].f > fMax) fMax = a [i].f;
  }

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

  //----------------------------------------------------------------------------
  for (int i = 0; i < popSize; i++)
  {
    agent [i].energy   = CalculateEnergy (i);

    agent [i].friction = u.Scale (a [i].f, fMin, fMax, 0.1, 1.0, false);

    agent [i].energy -= energyLoss;

    double newEnergy = CalculateEnergy (i);

    if (newEnergy > agent [i].energy)
    {
      agent [i].energy += energyLoss / 2;
      agent [i].hunger = 0;
    }
    else
    {
      agent [i].hunger++;
    }

    double growthRate = maxGrowthRate * agent [i].size / (agent [i].size + halfSaturationConstant);

    agent [i].size *= (1 + growthRate);
  }

  //----------------------------------------------------------------------------
  EvolutionProcess  ();
  AdaptationProcess ();
}
//——————————————————————————————————————————————————————————————————————————————

Beschreiben wir nun die Funktion EvolutionProcess (). Sie ist für die Evolution der Agenten in der Population verantwortlich. Der Hauptzweck dieser Funktion ist es, den am wenigsten geeigneten Agenten (die niedrigste Alge) zu finden und seine Koordinaten durch die Koordinaten von zufällig ausgewählten, besser geeigneten Agenten (höhere Algen) zu ersetzen.

1. Die Suche nach dem ungeeignetsten Agenten:

• Die Variable smallestIndex wird initialisiert. Sie speichert den Index des untauglichsten Agenten. Anfänglich auf 0 gesetzt.
• Die Schleife durchläuft alle Agenten (beginnend mit dem ersten) und vergleicht ihre Fitness. Wenn die Fitness des aktuellen Agenten geringer ist als die Fitness des Agenten mit dem Index smallestIndex, wird smallestIndex aktualisiert.

2. Kopieren von Koordinaten:

• Die Variable m zur Speicherung eines zufälligen Agentenindexes wird initialisiert.
• Die Schleife alle Koordinaten von 0 bis coords wird durchlaufen.
• Innerhalb der Schleife wird die Methode u.RNDminusOne (popSize) aufgerufen. Sie erzeugt den Zufallsindex m im Bereich von 0 bis popSize 1.
• Dann werden die Koordinaten des unpassendsten Agenten mit dem Index smallestIndex durch die Koordinaten eines zufälligen Agenten mit dem Index m ersetzt.

Die Funktion EvolutionProcess implementiert einen einfachen Evolutionsmechanismus, bei dem der am wenigsten geeignete Agent in der Population die Koordinaten eines zufälligen Agenten erhält. Dieser Vorgang ist Teil des Anpassungsmechanismus, der es den Agenten ermöglicht, ihre Eigenschaften zu verbessern, indem sie erfolgreichere Koordinaten von anderen Agenten auswählen. Im Allgemeinen führt er die kombinatorischen Funktionen des Algorithmus aus.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_AAA::EvolutionProcess ()
{
  int smallestIndex = 0;

  for (int i = 1; i < popSize; i++)
  {
    if (agent [i].size < agent [smallestIndex].size) smallestIndex = i;
  }

  int m = 0;

  for (int c = 0; c < coords; c++)
  {
    m = u.RNDminusOne (popSize);

    a [smallestIndex].c [c] = a [m].c [c];
  }
}
//——————————————————————————————————————————————————————————————————————————————

Schauen wir uns den Code der Funktion AdaptationProcess () genauer an. Er ist verantwortlich für die Anpassung der Agenten in der Population, basierend auf ihrem Hunger und ihrer Größe. Das Hauptziel der Funktion besteht darin, die Koordinaten des hungrigsten Agenten zu ändern, wenn eine bestimmte Bedingung der Anpassungswahrscheinlichkeit erfüllt ist.

1. Suche nach dem hungrigsten Erreger (Algen):

• Die Variable starvingIndex, die den Index des hungrigsten Agenten speichert, wird initialisiert. Sie wird anfänglich auf 0 gesetzt.
• Die Schleife durchläuft alle Agenten (beginnend mit dem ersten) und vergleicht die Hungerwerte. Wenn der Hungerlevel des aktuellen Agenten größer ist als der des Agenten mit dem Index von starvingIndex, wird starvingIndex aktualisiert.

2. Überprüfung der Anpassungswahrscheinlichkeit:

• Es wird die Methode u.RNDprobab () verwendet, die eine Zufallszahl (Wahrscheinlichkeit) erzeugt. Ist diese Zahl kleiner als die angegebene Anpassungswahrscheinlichkeit (adaptationProbability), wird der folgende Codeblock ausgeführt.

3. Suche nach dem höchsten Algen-Agenten:

• Ähnlich wie im ersten Schritt wird auch hier der Index des höchsten Agenten in der Population gesucht. Anfänglich ist biggestIndex auf 0 gesetzt.
• Die Schleife geht durch alle Agenten und aktualisiert BiggestIndex, wenn der aktuelle Agent höher ist.

4. Anpassung der Koordinaten:

• Es wird die Schleife über alle Koordinaten durchlaufen.
• Die Koordinaten des Agenten mit dem Index starvingIndex werden aktualisiert, indem der Wert addiert wird, der sich aus der Differenz zwischen den Koordinaten des höchsten Agenten und des hungrigsten Agenten ergibt, multipliziert mit einer Zufallswahrscheinlichkeit.
• Dann werden die Koordinaten mit der Methode u.SeInDiSp () normalisiert, die die Koordinaten innerhalb der angegebenen Grenzen rangeMin, rangeMax und rangeStep überprüft und anpasst.

5. Aktualisierung des Agentenstatus:

• Die Größe des Agenten wird durch den Fitnesswert f aus dem Array a aktualisiert.
• Es wird die Hungerstufe auf 0 gesetzt, was bedeutet, dass der Agent satt ist.
• Die Energie des Agenten wird auf 1,0 gesetzt. Dies ist der Höchstwert.

Die Funktion AdaptationProcess implementiert den Anpassungsmechanismus, der es dem hungrigsten Agenten ermöglicht, seine Koordinaten zu verbessern, indem er sie sich vom höchsten Agenten ausleiht, wenn die Wahrscheinlichkeitsbedingung erfüllt ist. Dies ist Teil eines Systems, das die natürliche Selektion nachahmt, bei der sich die Akteure an die Umwelt anpassen, um ihre Überlebenschancen zu verbessern.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_AAA::AdaptationProcess ()
{
  int starvingIndex = 0;

  for (int i = 1; i < popSize; i++) if (agent [i].hunger > agent [starvingIndex].hunger) starvingIndex = i;
  
  if (u.RNDprobab () < adaptationProbability)
  {
    int biggestIndex = 0;

    for (int i = 1; i < popSize; i++) if (agent [i].size > agent [biggestIndex].size) biggestIndex = i;

    for (int j = 0; j < coords; j++)
    {
      a [starvingIndex].c [j] += (a [biggestIndex].c [j] - a [starvingIndex].c [j]) * u.RNDprobab ();

      a [starvingIndex].c [j] = u.SeInDiSp (a [starvingIndex].c [j], rangeMin [j], rangeMax [j], rangeStep [j]);
    }

    agent [starvingIndex].size   = a [starvingIndex].f;
    agent [starvingIndex].hunger = 0;
    agent [starvingIndex].energy = 1.0;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Als Nächstes folgt der Code der Funktion CalculateEnergy. Es wurde entwickelt, um die Energie eines bestimmten Mittels auf der Grundlage seiner Eigenschaften, wie Koloniegröße, Energieniveau und Nährstoffkonzentration, zu berechnen. Die Funktion gibt den Energiewert zurück, der in anderen Teilen des Algorithmus verwendet wird.

1. Initialisierung von Variablen:

• colony_size — ermittelt die Größe der Algen anhand des Index.
• max_growth_rate — maximale Wachstumsrate.
• half_saturation_constant — die Hälfte der Sättigungskonstante.

2. Normalisierung der Fitnessfunktion: Es wird der normalisierte Wert der Nährstoffkonzentration berechnet. Er wird berechnet als das Verhältnis der Differenz zwischen f (aus dem Array a) und dem Mindestwert von fMin zum Bereich zwischen fMax und fMin. Die Addition von 1e-10 verhindert ein Teilen durch Null.

3. Ermittlung der aktuellen Wachstumsrate: current_growth_rate — ermittelt den aktuellen Wert der Energie des Agenten, der auch als aktuelle Wachstumsrate interpretiert wird.

4. Berechnung der Wachstumsrate: growth_rate — berechnet auf der Grundlage der maximalen Wachstumsrate, der normalisierten Nährstoffkonzentration und der aktuellen Wachstumsrate. Die Gleichung berücksichtigt den Sättigungseffekt, bei dem die Wachstumsrate mit steigender aktueller Wachstumsrate abnimmt.

5. Energieberechnung: Die Energie wird als Differenz zwischen der Wachstumsrate und einigen Energieverlusten (energyLoss) berechnet. Dieser Wert gibt an, wie viel Energie der Agent nach Berücksichtigung der Verluste erhält.

6. Wenn die berechnete Energie negativ ist, wird sie auf 0 gesetzt. Dadurch werden negative Energiewerte vermieden.

7. Die Funktion gibt den berechneten Energiewert zurück.

Die Funktion CalculateEnergy modelliert einen Prozess, bei dem ein Agent auf der Grundlage seiner Wachstumsrate, Koloniegröße und Nährstoffkonzentration Energie gewinnt. Es berücksichtigt auch Energieverluste, um ein realistisches Verhalten der Agenten in der Simulation zu gewährleisten. 

//——————————————————————————————————————————————————————————————————————————————
double C_AO_AAA::CalculateEnergy (int index)
{
  double colony_size              = agent [index].size;
  double max_growth_rate          = maxGrowthRate;
  double half_saturation_constant = halfSaturationConstant;

  // Use the normalized value of the fitness function
  double nutrient_concentration = (a [index].f - fMin) / (fMax - fMin + 1e-10);

  double current_growth_rate = agent [index].energy;

  double growth_rate = max_growth_rate * nutrient_concentration / (half_saturation_constant + current_growth_rate) * colony_size;

  double energy = growth_rate - energyLoss;

  if (energy < 0) energy = 0;

  return energy;
}
//——————————————————————————————————————————————————————————————————————————————

Die letzte Methode besteht darin, den Mechanismus der Turnierauswahl zu implementieren. Die Methode TournamentSelection wählt einen der beiden Kandidaten aus der Population auf der Grundlage ihrer Fitnessfunktionswerte aus. Sie gibt den Index des Kandidaten mit dem besten Fitnesswert zurück. Die Turnierauswahl bietet eine Auswahl. Wir haben bereits oben die Wahrscheinlichkeitsverteilungen unter den Agenten in der Population betrachtet.

//——————————————————————————————————————————————————————————————————————————————
int C_AO_AAA::TournamentSelection ()
{
  int candidate1 = u.RNDminusOne (popSize);
  int candidate2 = u.RNDminusOne (popSize);

  return (a [candidate1].f > a [candidate2].f) ? candidate1 : candidate2;
}
//——————————————————————————————————————————————————————————————————————————————

Testergebnisse

Ergebnisse des AAA-Tests:

AAA|Algae Adaptive Algorithm|200.0|0.2|0.05|0.1|0.1|
=============================
5 Hilly's; Func runs: 10000; result: 0.5000717048088521
25 Hilly's; Func runs: 10000; result: 0.3203956013467087
500 Hilly's; Func runs: 10000; result: 0.25525273777603685
=============================
5 Forest's; Func runs: 10000; result: 0.37021025883379577
25 Forest's; Func runs: 10000; result: 0.2228350161785575
500 Forest's; Func runs: 10000; result: 0.16784823154308887
=============================
5 Megacity's; Func runs: 10000; result: 0.2784615384615384
25 Megacity's; Func runs: 10000; result: 0.14800000000000005
500 Megacity's; Func runs: 10000; result: 0.097553846153847
=============================
All score: 2.36063 (26.23%)

Sowohl der Ausdruck als auch die Visualisierung der Funktionsweise des Algorithmus zeigen eine schwache Konvergenz, was durch die Testergebnisse bestätigt wird. Leider wurden meine Erwartungen an hohe Ergebnisse nicht erfüllt. Betrachtet man eine komplexe Suchstrategie für einen Algorithmus, so ist es schwierig, die Gründe für seine Ineffizienz zu ermitteln, da er das globale Optimum nur schwach lokalisiert. Trotz dieser Unzulänglichkeiten hat der Algorithmus jedoch auch seine Vorteile.

AAA mit der Testfunktion Hilly

AAA mit der Testfunktion Forest

AAA mit der Testfunktion Megacity

Auf der Grundlage der Testergebnisse rangiert der Algorithmus in der Bewertungstabelle auf Platz 36.

#	AO	Beschreibung	Hilly			Hilly final	Forest			Forest final	Megacity (discrete)			Megacity final	Final result	% of MAX
			10 p (5 F)	50 p (25 F)	1000 p (500 F)		10 p (5 F)	50 p (25 F)	1000 p (500 F)		10 p (5 F)	50 p (25 F)	1000 p (500 F)
1	ANS	Suche über die gesamte Nachbarschaft	0.94948	0.84776	0.43857	2.23581	1.00000	0.92334	0.39988	2.32323	0.70923	0.63477	0.23091	1.57491	6.134	68.15
2	CLA	Сode Lock Algorithmus	0.95345	0.87107	0.37590	2.20042	0.98942	0.91709	0.31642	2.22294	0.79692	0.69385	0.19303	1.68380	6.107	67.86
3	AMOm	Optimierung der Tiermigration M	0,90358	0,84317	0,46284	2,20959	0,99001	0,92436	0,46598	2,38034	0,56769	0,59132	0,23773	1,39675	5.987	66,52
4	(P+O)ES	(P+O) Entwicklungsstrategien	0.92256	0.88101	0.40021	2.20379	0.97750	0.87490	0.31945	2.17185	0.67385	0.62985	0.18634	1.49003	5.866	65.17
5	CTA	Kometenschweif-Algorithmus	0.95346	0.86319	0.27770	2.09435	0.99794	0.85740	0.33949	2.19484	0.88769	0.56431	0.10512	1.55712	5.846	64.96
6	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
7	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
8	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
9	ACS	künstliche, kooperative Suche	0.75547	0.74744	0.30407	1.80698	1.00000	0.88861	0.22413	2.11274	0.69077	0.48185	0.13322	1.30583	5.226	58.06
10	ASO	Anarchische Gesellschaftsoptimierung	0,84872	0,74646	0,31465	1,90983	0,96148	0,79150	0,23803	1,99101	0,57077	0,54062	0,16614	1,27752	5.178	57,54
11	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
12	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
13	CRO	Optimierung chemischer Reaktionen	0.94629	0.66112	0.29853	1.90593	0.87906	0.58422	0.21146	1.67473	0.75846	0.42646	0.12686	1.31178	4.892	54.36
14	BSA	Vogelschwarm-Algorithmus	0.89306	0.64900	0.26250	1.80455	0.92420	0.71121	0.24939	1.88479	0.69385	0.32615	0.10012	1.12012	4.809	53.44
15	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
16	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
17	(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
18	BSO	Brainstorming-Optimierung	0.93736	0.57616	0.29688	1.81041	0.93131	0.55866	0.23537	1.72534	0.55231	0.29077	0.11914	0.96222	4.498	49.98
19	WOAm	Algorithmus zur Optimierung des Wals 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
20	AEFA	Algorithmus für künstliche elektrische Felder	0.87700	0.61753	0.25235	1.74688	0.92729	0.72698	0.18064	1.83490	0.66615	0.11631	0.09508	0.87754	4.459	49.55
21	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
22	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
23	ABHA	Algorithmus für künstliche Bienenstöcke	0.84131	0.54227	0.26304	1.64663	0.87858	0.47779	0.17181	1.52818	0.50923	0.33877	0.10397	0.95197	4.127	45.85
24	ASBO	Optimierung des adaptiven Sozialverhaltens	0.76331	0.49253	0.32619	1.58202	0.79546	0.40035	0.26097	1.45677	0.26462	0.17169	0.18200	0.61831	3.657	40.63
25	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
26	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
27	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
28	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
29	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
30	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
31	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
32	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
33	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
34	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
35	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
36	AAA	Künstlicher Algenalgorithmus (AAA)	0.50007	0.32040	0.25525	1.07572	0.37021	0.22284	0.16785	0.76089	0.27846	0.14800	0.09755	0.52402	2.361	26.23
37	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
38	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
39	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
40	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
41	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
42	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
43	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
44	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
45	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

Zusammenfassung

Der Ausdruck zeigt eine geringe Konvergenz. Etwas enttäuscht bin ich von den Fähigkeiten des Algorithmus: Trotz der Verwendung mehrerer Methoden und einer komplexen Schrittlogik ist er am Ende der Tabelle gelandet. Vielleicht lohnt es sich, den verwendeten Methoden mehr Aufmerksamkeit und Verständnis zu schenken, da ihre Quantität nicht immer Qualität garantiert. Es steht den Lesern frei, damit zu experimentieren, und wenn der Algorithmus bessere Ergebnisse liefert, teilen Sie sie bitte mit. Ich freue mich auf Kommentare zu diesem Artikel.

Zu den positiven Aspekten des Algorithmus gehören gute Ergebnisse bei den Testfunktionen von Forest und Megacity mit 1000 Variablen im Vergleich zu seinen nächsten Konkurrenten. Dies zeigt das Potenzial des Algorithmus in Bezug auf die Skalierbarkeit bei Problemen mit „spitzen“ Extremen und diskreten Problemen.

Abbildung 1. Farbliche Abstufung der Algorithmen entsprechend den relevanten Tests Ergebnisse, die größer oder gleich 0,99 sind, werden weiß hervorgehoben

Abbildung 2. Das Histogramm der Algorithmus-Testergebnisse (auf einer Skala von 0 bis 100, je mehr, desto besser,

wobei 100 das maximal mögliche theoretische Ergebnis ist; im Archiv befindet sich ein Skript zur Berechnung der Wertungstabelle)

AAA Pro und Kontra:

Vorteile:

1. Vielversprechende Idee und innovative Ansätze.

Nachteile

1. Große Anzahl von Parametern (sehr schwierig zu konfigurieren).
   
2. Schwache Konvergenz.
3. Schwierig zu debuggen.

Der Artikel wird von einem Archiv mit den aktuellen Versionen der Codes der Algorithmem 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.

• github: https://github.com/JQSakaJoo/Population-optimization-algorithms-MQL5
• CodeBase: https://www.mql5.com/ru/code/49355