Algorithmen zur Optimierung mit Populationen Grauer-Wolf-Optimierung (GWO)

Inhalt

1. Einführung
2. Beschreibung des Algorithmus
3. Testfunktionen
4. Testergebnisse

1. Einführung

Der Graue-Wolf-Algorithmus ist ein metaheuristischer, stochastischer Schwarmintelligenz-Algorithmus, der 2014 entwickelt wurde. Seine Idee basiert auf dem Modell der Jagd auf graue Wolfsrudel. Es gibt vier Arten von Wölfen: Alpha, Beta, Delta und Omega. Der Alpha hat das meiste „Gewicht“ bei der Entscheidungsfindung und der Führung des Rudels. Danach kommen die Beta- und die Delta-Wölfe, die dem Alpha gehorchen und Macht über die übrigen Wölfe haben. Der Omega-Wolf gehorcht immer dem Rest der dominanten Wölfe.

Im mathematischen Modell der Wolfshierarchie wird der Alpha-α-Wolf als der dominante Wolf im Rudel angesehen, und seine Befehle sollten von den Mitgliedern des Rudels ausgeführt werden. Beta-β-untergeordnete Wölfe unterstützen das Alphatier bei der Entscheidungsfindung und gelten als die besten Kandidaten für die Rolle des Alphatiers. Delta-Wölfe δ sollten Alpha und Beta gehorchen und sie beherrschen Omega. Omega ω-Wölfe gelten als die Sündenböcke des Rudels und als die unwichtigsten Individuen. Sie dürfen erst zum Schluss essen. Alpha wird als die günstigste Lösung angesehen.

Die zweit- und drittbeste Lösung sind Beta bzw. Delta. Die übrigen Lösungen gelten als Omega. Es wird davon ausgegangen, dass die fittesten Wölfe (Alpha, Beta und Delta), d. h. diejenigen, die der Beute am nächsten sind, vom Rest der Wölfe angegangen werden. Nach jeder Annäherung wird festgestellt, wer in dieser Phase Alpha, Beta und Delta ist, und dann werden die Wölfe wieder neu geordnet. Die Formation erfolgt so lange, bis sich die Wölfe zu einem Rudel zusammenfinden, das die optimale Richtung für einen Angriff mit minimalem Abstand darstellt.

Während des Algorithmus werden 3 Hauptphasen durchgeführt, in denen die Wölfe nach Beute suchen, sie einkreisen und angreifen. Die Suche ergibt Alpha, Beta und Delta - die Wölfe, die der Beute am nächsten sind. Der Rest, der den dominanten Tieren gehorcht, kann beginnen, die Beute zu einzukreisen oder sich auf der Suche nach der besten Möglichkeit wahllos zu bewegen.

2. Beschreibung des Algorithmus

Die Hierarchie im Paket ist in Abbildung 1 schematisch dargestellt.  Alpha spielt eine dominante Rolle.

Abb. 1. Soziale Hierarchie in einem Wolfsrudel

Mathematisches Modell und Algorithmus
Soziale Hierarchie:

• Die beste Lösung in Form eines Alpha-Wolfs (α).
• Die zweitbeste Lösung als Beta-Wolf (β).
• Die drittbeste Lösung als Delta-Wolf (δ).
• Andere mögliche Lösungen als Omega-Wölfe (ω).

Einkreisen der Beute: Wenn es bereits die besten Alpha-, Beta- und Delta-Lösungen gibt, hängen die weiteren Aktionen von Omega ab.

Abb. 2. Jagdphasen: Suche, Einkreisung, Angriff.

Alle Iterationen des Algorithmus werden durch drei Phasen dargestellt: Suche, Umkreisung und Jagd. Die kanonische Version des Algorithmus zeichnet sich durch einen Koeffizienten а aus, der zur Verbesserung der Konvergenz des Algorithmus eingeführt wurde. Der Koeffizient sinkt bei jeder Iteration auf Null. Solange der Koeffizient über 1 liegt, werden die Wölfe initialisiert. In dieser Phase ist die Position der Beute völlig unbekannt, sodass die Wölfe nach dem Zufallsprinzip verteilt werden sollten.

Nach der „Suchphase“ wird der Wert der Fitnessfunktion bestimmt, und erst dann kann man zur „Einkreisungsphase“ übergehen. In dieser Phase ist der Koeffizient a größer als 1. Dies bedeutet, dass sich Alpha, Beta und Delta von ihren vorherigen Positionen entfernen und somit die Position der geschätzten Beute verfeinert werden kann. Wenn der Koeffizient а gleich 1 wird, beginnt die „Angriffsphase“, während der Koeffizient vor dem Ende der Iterationen gegen 0 tendiert. Dies veranlasst die Wölfe, sich der Beute zu nähern, was darauf hindeutet, dass die beste Position bereits gefunden wurde. Wenn in dieser Phase einer der Wölfe eine bessere Lösung findet, werden zwar die Position der Beute und die Hierarchie der Wölfe aktualisiert, aber der Koeffizient tendiert weiterhin gegen 0. Der Prozess der Veränderung von a wird durch eine nichtlineare Funktion dargestellt. Die Phasen sind in Abbildung 2 schematisch dargestellt.

Das Verhalten der Omega-Wölfe ist in allen Epochen unverändert und besteht darin, der geometrischen Mitte zwischen den Positionen der derzeit dominanten Individuen zu folgen. In Abbildung 3 weichen Alpha, Beta und Delta von ihrer vorherigen Position in einer zufälligen Richtung mit einem Radius ab, der durch die Koeffizienten gegeben ist, und Omegas bewegen sich zur Mitte zwischen ihnen, weichen aber mit einer gewissen Wahrscheinlichkeit innerhalb des Radius von ihr ab. Die Radien bestimmen den Koeffizienten а, der sich, wie wir uns erinnern, ändert, wodurch die Radien proportional abnehmen.

Abb. 3. Diagramm der Omega-Bewegung im Verhältnis zu Alpha, Beta und Delta

Der Pseudocode des GWO-Algorithmus lautet wie folgt:

1) Initialisieren der Population der Grauen Wölfe nach dem Zufallsprinzip.
2) Berechnen der Fitness der einzelnen Mitglieder der Population.
3) Rudelführer:
-α = Mitglied mit dem besten Fitnesswert
-β = zweitbestes Mitglied (in Bezug auf die Fitness)
-δ = drittbestes Mitglied (in Bezug auf den Fitnesswert)
Aktualisierung der Position aller Omega-Wölfe gemäß den Gleichungen, die von α, β, δ abhängen
4) Berechnen der Fitness der einzelnen Mitglieder der Population.
5) Schritt 3 wiederholen.

Kommen wir nun zum Algorithmus selbst. Die einzige Ergänzung, die ich gegenüber der ursprünglichen Version vorgenommen habe, ist die Möglichkeit, die Anzahl der Leitwölfe im Rudel festzulegen. Jetzt können wir eine beliebige Anzahl von Anführern festlegen, bis hin zum gesamten Rudel. Dies kann für bestimmte Aufgaben nützlich sein.

Wir beginnen, wie üblich, mit der elementaren Einheit des Algorithmus - dem Wolf, der eine Lösung des Problems darstellt. Dies ist eine Struktur, die eine Reihe von Koordinaten und einen Beutewert (Fitnessfunktionen) enthält. Die Struktur ist für Anführer und untergeordnete Mitglieder des Rudels gleich. Dies vereinfacht den Algorithmus und ermöglicht es uns, dieselben Strukturen in den Schleifenoperationen zu verwenden. Außerdem wechseln die Rollen der Wölfe während aller Iterationen mehrmals. Die Rollen sind eindeutig durch die Position im Array nach der Sortierung bestimmt. Die Anführer stehen am Anfang der Reihe.

//——————————————————————————————————————————————————————————————————————————————
struct S_Wolf
{
  double c []; //coordinates
  double p;    //prey
};
//——————————————————————————————————————————————————————————————————————————————

Das Wolfsrudel wird durch eine kompakte und verständliche Klasse repräsentiert. Hier geben wir die Bereiche und den Schritt der zu optimierenden Parameter, die beste Produktionsposition, den besten Lösungswert und Hilfsfunktionen an.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_GWO //wolfpack
{
  //============================================================================
  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //manimum search range
  public: double rangeStep []; //step search
  public: S_Wolf wolves    []; //wolves of the pack
  public: double cB        []; //best prey coordinates
  public: double pB;           //best prey

  public: void InitPack (const int    coordinatesP,   //number of opt. parameters
                         const int    wolvesNumberP,  //wolves number
                         const int    alphaNumberP,   //alpha beta delta number
                         const int    epochCountP);   //epochs number

  public: void TasksForWolves      (int epochNow);
  public: void RevisionAlphaStatus ();


  //============================================================================
  private: void   ReturnToRange (S_Wolf &wolf);
  private: void   SortingWolves ();
  private: double SeInDiSp      (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI     (double Min, double Max);

  private: int    coordinates;     //coordinates number
  private: int    wolvesNumber;    //the number of all wolves
  private: int    alphaNumber;     //Alpha beta delta number of all wolves
  private: int    epochCount;

  private: S_Wolf wolvesT    [];   //temporary, for sorting
  private: int    ind        [];   //array for indexes when sorting
  private: double val        [];   //array for sorting

  private: bool   searching;       //searching flag
};
//——————————————————————————————————————————————————————————————————————————————

Traditionell folgt auf die Klassendeklaration die Initialisierung. Hier setzen wir auf den minimalen „double“ Wert der Fitness der Wölfe zurück und verteilen die Größe der Felder.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO::InitPack (const int    coordinatesP,   //number of opt. parameters
                         const int    wolvesNumberP,  //wolves number
                         const int    alphaNumberP,   //alpha beta delta number
                         const int    epochCountP)    //epochs number
{
  MathSrand (GetTickCount ());
  searching = false;
  pB        = -DBL_MAX;

  coordinates  = coordinatesP;
  wolvesNumber = wolvesNumberP;
  alphaNumber  = alphaNumberP;
  epochCount   = epochCountP;

  ArrayResize (rangeMax,  coordinates);
  ArrayResize (rangeMin,  coordinates);
  ArrayResize (rangeStep, coordinates);
  ArrayResize (cB,        coordinates);

  ArrayResize (ind, wolvesNumber);
  ArrayResize (val, wolvesNumber);

  ArrayResize (wolves,  wolvesNumber);
  ArrayResize (wolvesT, wolvesNumber);

  for (int i = 0; i < wolvesNumber; i++)
  {
    ArrayResize (wolves  [i].c, coordinates);
    ArrayResize (wolvesT [i].c, coordinates);
    wolves  [i].p = -DBL_MAX;
    wolvesT [i].p = -DBL_MAX;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Die erste öffentliche Methode, die bei jeder Iteration aufgerufen wird, ist am schwierigsten zu verstehen und am umfangreichsten. Hier ist die Hauptlogik des Algorithmus. Die Leistung des Algorithmus wird nämlich durch einen probabilistischen Mechanismus gewährleistet, der streng durch Gleichungen beschrieben wird. Gehen wir diese Methode Schritt für Schritt durch. Bei der ersten Iteration, wenn die Position der beabsichtigten Beute unbekannt ist, schicken wir die Wölfe nach der Überprüfung der Flag in eine zufällige Richtung, indem wir einfach Werte aus den Maximal- und Minimalwerten der optimierten Parameter generieren.

//----------------------------------------------------------------------------
//space has not been explored yet, then send the wolf in a random direction
if (!searching)
{
  for (int w = 0; w < wolvesNumber; w++)
  {
    for (int c = 0; c < coordinates; c++)
    {
      wolves [w].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
      wolves [w].c [c] = SeInDiSp  (wolves [w].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }
   
  searching = true;
  return;
}

In der kanonischen Version der Algorithmusbeschreibung gibt es Gleichungen, die mit Vektoren arbeiten. In Codeform sind sie jedoch viel deutlicher. Die Berechnung der Omega-Wölfe wird vor der Berechnung der Alpha-, Beta- und Delta-Wölfe durchgeführt, da wir die vorherigen Leader-Werte verwenden müssen.

Die Hauptkomponente, die die drei Phasen der Jagd (Suchen, Einkreisen und Angriff) ermöglicht, ist der Koeffizient a. Er stellt eine nichtlineare Abhängigkeit von der aktuellen Iteration und der Gesamtzahl der Iterationen dar und tendiert gegen 0.
Die nächsten Komponenten der Gleichung sind Ai und Сi:

• Ai = 2,0 * a * r1 - a;
• Ci = 2,0 * r2;

wobei r1 und r2 Zufallszahlen im Bereich [0,0;1,0] sind.
In dem Ausdruck werden die Koordinaten der Wölfe entsprechend den Durchschnittswerten der Leitwölfe angepasst. Da in dem Algorithmus eine beliebige Anzahl von Anführern angegeben werden kann, wird die Summierung der Koordinaten in einer Schleife durchgeführt. Anschließend wird der sich ergebende Betrag durch die Anzahl der Anführer geteilt. Wir führen diesen Vorgang für jede Koordinate separat durch, wobei jedes Mal neue Werte für r1 und r2 erzeugt werden. Wie wir sehen können, wird die neue Position der Omega-Wölfe entsprechend den Positionen der Anführer unter Berücksichtigung ihrer eigenen aktuellen Position angepasst.

//----------------------------------------------------------------------------
double a  = sqrt (2.0 * (1.0 - (epochNow / epochCount)));
double r1 = 0.0;
double r2 = 0.0;

double Ai = 0.0;
double Ci = 0.0;
double Xn = 0.0;

double min = 0.0;
double max = 1.0;

//omega-----------------------------------------------------------------------
for (int w = alphaNumber; w < wolvesNumber; w++)
{
  Xn = 0.0;

  for (int c = 0; c < coordinates; c++)
  {
    for (int abd = 0; abd < alphaNumber; abd++)
    {
      r1 = RNDfromCI (min, max);
      r2 = RNDfromCI (min, max);
      Ai = 2.0 * a * r1 - a;
      Ci = 2.0 * r2;
      Xn += wolves [abd].c [c] - Ai * (Ci * wolves [abd].c [c] - wolves [w].c [c]);
    }

    wolves [w].c [c] = Xn /= (double)alphaNumber;
  }

  ReturnToRange (wolves [w]);
}

Hier werden die Anführer berechnet. Für sie werden die Koeffizienten a, Ai und Ci für jede Koordinate berechnet. Der einzige Unterschied besteht darin, dass sich die Position der Anführer im Verhältnis zu den besten Beutekoordinaten zum aktuellen Zeitpunkt und ihren eigenen Positionen ändert. Die Anführer kreisen die Beute ein, bewegen sich nach innen und außen und kontrollieren die kleineren Wölfe bei ihrem Angriff.

//alpha, beta, delta----------------------------------------------------------
for (int w = 0; w < alphaNumber; w++)
{
  for (int c = 0; c < coordinates; c++)
  {
    r1 = RNDfromCI (min, max);
    r2 = RNDfromCI (min, max);

    Ai = 2.0 * a * r1 - a;
    Ci = 2.0 * r2;

    wolves [w].c [c] = cB [c] - Ai * (Ci * cB [c] - wolves [w].c [c]);
  }

  ReturnToRange (wolves [w]);
}

Dies ist die zweite öffentliche Methode, die bei jeder Iteration aufgerufen wird. Der Status der Führenden im Rudel wird hier aktualisiert. Die Wölfe sind nämlich nach ihrem Fitnesswert sortiert. Wenn bessere Beutekoordinaten als die im Schwarm gespeicherten gefunden werden, aktualisieren wir die Werte.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO::RevisionAlphaStatus ()
{
  SortingWolves ();

  if (wolves [0].p > pB)
  {
    pB = wolves [0].p;
    ArrayCopy (cB, wolves [0].c, 0, 0, WHOLE_ARRAY);
  }
}
//——————————————————————————————————————————————————————————————————————————————

3. Testfunktionen

Sie kennen bereits die Funktionen Skin, Forest und Megacity. Diese Testfunktionen erfüllen alle Komplexitätskriterien für das Testen von Optimierungsalgorithmen. Es gibt jedoch eine Besonderheit, die nicht berücksichtigt wurde. Sie sollte eingeführt werden, um die Objektivität der Prüfung zu erhöhen. Die Anforderungen sind wie folgt:

1. Das globale Extremum sollte nicht an den Grenzen des Bereichs liegen. Verfügt der Algorithmus nicht über eine Bereichsüberschreitungsprüfung, sind Situationen möglich, in denen der Algorithmus hervorragende Ergebnisse liefert. Dies ist darauf zurückzuführen, dass die Werte aufgrund eines internen Fehlers an den Rändern liegen werden.
2. Das globale Extremum sollte nicht in der Mitte der Koordinaten des Bereichs liegen. In diesem Fall wird der Algorithmus, der in einem Bereich gemittelte Werte erzeugt, berücksichtigt.
3. Das globale Minimum sollte sich in der Mitte der Koordinaten befinden. Dies ist notwendig, um die auf S. 2 beschriebenen Situationen bewusst auszuschließen.
4. Bei der Berechnung der Ergebnisse der Testfunktion sollte der Fall berücksichtigt werden, dass zufällig erzeugte Zahlen über den gesamten Bereich der Funktion (wenn es sich um eine multivariable Funktion handelt) ein durchschnittliches Ergebnis von etwa 50 % des Maximums ergeben, obwohl diese Ergebnisse tatsächlich zufällig erzielt wurden.
   

Unter Berücksichtigung dieser Anforderungen wurden die Grenzen der Testfunktionen überarbeitet und die Mittelpunkte des Bereichs auf die Minima der Funktionswerte verschoben. Fassen wir noch noch einmal zusammen. Dies war notwendig, um eine größtmögliche Plausibilität und Objektivität der Ergebnisse der Testoptimierungsalgorithmen zu erreichen. Daher zeigte der Optimierungsalgorithmus, der auf der Erzeugung von Zufallszahlen basiert, bei neuen Testfunktionen ein natürlich niedriges Gesamtergebnis. Die aktualisierte Bewertungstabelle befindet sich am Ende des Artikels.

Die Skin-Funktion. Eine glatte Funktion, die mehrere lokale Extrema aufweist, die den Optimierungsalgorithmus verwirren können, da er in einem von ihnen stecken bleiben kann. Das einzige globale Extremum ist durch schwach wechselnde Werte in der Umgebung gekennzeichnet. Diese Funktion zeigt deutlich, dass der Algorithmus in verschiedene Bereiche unterteilt werden kann, anstatt sich auf einen einzigen Bereich zu konzentrieren. Insbesondere der Bienenvolk-Algorithmus (ABC) verhält sich auf diese Weise.

Abb. 4. Funktion des Skin-Tests

Die Forest-Funktion. Eine Funktion mit mehreren glatten und mehreren nicht-differenzierbaren Extrema. Dies ist ein wertvoller Test für Optimierungsalgorithmen, um eine „Nadel im Heuhaufen“ zu finden. Die Suche nach einem einzigen globalen Maximalpunkt ist eine sehr schwierige Aufgabe, insbesondere wenn die Funktion viele Variablen enthält. Der Ameisenkolonie-Algorithmus (ACO) zeichnet sich bei dieser Aufgabe durch das charakteristische Verhalten aus, das auf unglaubliche Weise Wege zum Ziel bahnt.

Abbildung 5, Testfunktion von Forest

Die Megacity-Funktion. Die Funktion ist ein diskretes Optimierungsproblem mit einem globalen und mehreren lokalen Extrema. Die extrem komplexe Oberfläche bietet einen guten Test für Algorithmen, die einen Gradienten benötigen. Eine zusätzliche Komplexität wird durch einen völlig ebenen „Boden“ hinzugefügt, der ebenfalls ein Minimum ist, das keine Informationen über die mögliche Richtung zum globalen Maximum gibt.

Abbildung 6, Testfunktion von Megacity

Der Code der Testfunktionen wurde um Überprüfungen der eingehenden Argumente auf Werte außerhalb des zulässigen Bereichs erweitert. In den früheren Versionen der Funktionen konnten Optimierungsalgorithmen auf unfaire Weise Funktionswerte erhalten, die größer waren als die tatsächlichen Werte der Funktion innerhalb ihres Definitionsbereichs.

4. Testergebnisse

Aufgrund der Änderungen der Prüffunktionen wurde auch der Prüfstand aktualisiert. Auf der rechten Seite des Standbildschirms sind weiterhin die Konvergenzkurven der Optimierungsalgorithmen zu sehen. Die grüne Linie steht für die Ergebnisse der Konvergenz bei Funktionen mit zwei Variablen. Die blaue Linie steht für die Funktionen mit 40 Variablen. Die rote Farbe steht für Funktionen mit 1000 Variablen. Der größere schwarze Kreis zeigt die Position des globalen Maximums der Funktion an. Der kleinere schwarze Kreis zeigt die Position des aktuellen Lösungswertes des Optimierungsalgorithmus an. Das Fadenkreuz aus weißen Linien zeigt den geometrischen Mittelpunkt der Testfunktionen und entspricht dem globalen Minimum. Dies wurde eingeführt, um das Verhalten der getesteten Algorithmen besser sichtbar zu machen. Die weißen Punkte zeigen gemittelte Zwischenlösungen an. Farbige kleine Punkte kennzeichnen Koordinatenpaare der entsprechenden Dimension. Die Farbe gibt die ordinale Position der Dimension der Testfunktion an.

Die aktualisierten Ergebnisse der Tests der in früheren Artikeln besprochenen Optimierungsalgorithmen auf dem neuen Stand sind in der aktualisierten Tabelle zu sehen. Für mehr visuelle Klarheit wurde die Zeile über die Konvergenzgeschwindigkeit aus der Tabelle entfernt - sie kann auf der Animation des Standes visuell bestimmt werden. Die Spalte mit der Algorithmusbeschreibung wurde hinzugefügt.

ACO (Ant Colony Optimization) Testergebnisse:

ABCm (Künstliches Bienenvolk) Testergebnisse:

ABC (Artificial Bee Colony) Testergebnisse:

PSO (Partikelschwarm-Optimierung) Testergebnisse

RND (Random) Testergebnisse:

  ACO mit der Testfunktion Skin

ACO mit der Testfunktion Forest

  ACO mit der Testfunktion Megacity

GWO-Testergebnisse.

Der Graue-Wölfe-Optimierungsalgorithmus (GWO) ist einer der jüngsten bio-inspirierten Optimierungsalgorithmen, der auf der simulierten Jagd eines Rudels grauer Wölfe basiert. Im Durchschnitt hat sich der Algorithmus bei verschiedenen Funktionstypen als recht effizient erwiesen, sowohl was die Genauigkeit bei der Suche nach einem Extremum als auch was die Konvergenzgeschwindigkeit betrifft. In einigen Tests hat sie sich als der beste herausgestellt. Die wichtigsten Leistungsindikatoren des Optimierungsalgorithmus „Graue Wölfe“ sind besser als die des Algorithmus der Partikelschwarmoptimierung, der als „konventionell“ in der Klasse der bio-inspirierten Optimierungsalgorithmen gilt.

Gleichzeitig ist die Rechenkomplexität des Graue-Wölfe-Optimierungsalgorithmus vergleichbar mit der des Partikelschwarm-Optimierungsalgorithmus. Aufgrund der zahlreichen Vorteile des GWO-Optimierungsalgorithmus sind in der kurzen Zeit seit der ersten Veröffentlichung des Algorithmus viele Arbeiten zu seiner Modifizierung erschienen. Der einzige Nachteil des Algorithmus ist die geringe Genauigkeit der gefundenen Koordinaten der Funktion sharp-maximum für Forest,

Die geringe Genauigkeit des gefundenen Extremwerts zeigte sich in allen Dimensionen der Forest-Funktion, und die Ergebnisse sind die schlechtesten unter allen Teilnehmern in der Tabelle. Der Algorithmus erwies sich bei der glatten Skin-Funktion als effizient, insbesondere bei der Skin-Funktion mit größerer Dimension. GWO ist auch der Dritte in der Tabelle, der bei der Funktion Megacity einen Treffer von 100 % beim globalen Maximum erzielt.

AO	Beschreibung	Skin			Forest			Megacity (diskret)			Endergebnis
		2 Parameter (1 F)	40 Parameter (20 F)	1000 Parameter (500 F)	2 Parameter (1 F)	40 Parameter (20 F)	1000 Parameter (500 F)	2 Parameter (1 F)	40 Parameter (20 F)	1000 Parameter (500 F)
ACOm	Ameisenkolonie-Optimierung (ACO)	0.98229.	0.79108.	0.12602.	1.00000	0.62077.	0.11521.	0.38333.	0.44000.	0.02377.	0.49805222
ABCm	Künstliches Bienenvolk (Artificial Bee Colony, ABC)	1.00000	0.63922.	0.08076	0.99908.	0.20112	0.03785.	1.00000	0.16333.	0.02823.	0.46106556
ABC	Künstliches Bienenvolk (Artificial Bee Colony, ABC)	0.99339.	0.73381.	0.11118.	0.99934.	0.21437.	0.04215.	0.85000.	0.16833.	0.03130.	0.46043000
GWO	Grauer-Wolf-Optimierung	0.99900	0.48033.	0.18924.	0.83844.	0.08755.	0.02555.	1.00000	0.10000	0.02187.	0.41577556
PSO	Partikelschwarmoptimierung	0.99627.	0.38080.	0.05089.	0.93772.	0.14540.	0.04856.	1.00000	0.09333.	0.02233.	0.40836667
RND	zufällig	0.99932.	0.44276.	0.06827.	0.83126.	0.11524.	0.03048.	0.83333.	0.09000.	0.02403.	0.38163222

Schlussfolgerungen: