Hybridisierung von Populationsalgorithmen. Sequentielle und parallele Strukturen

Inhalt

1. Einführung
2. Experimentieren mit GWO und COA
3. Experimentieren mit ESG und SDSm
4. Schlussfolgerungen

1. Einführung

Betrachten wir drei Hauptoptionen für die Hybridisierung von Optimierungsalgorithmen:

1. Vermischen von Algorithmus-Suchstrategien in einer einzigen. Jeder Algorithmus verfügt über eine eigene Reihe von Fähigkeiten und Fertigkeiten. Die Vermischung ihrer logischen Strukturen bietet eine Vielzahl von Eigenschaften für das gemeinsame Streben nach Erfolg. Es handelt sich um einen Tanz mit verschiedenen Stilen, bei dem jeder Schritt die Gesamtbewegung ergänzt und verstärkt. Ein Beispiel für einen solchen Ansatz ist die Bacterial Foraging Optimization in Kombination mit dem genetischen Algorithmus, der in einem der vorangegangenen Artikel behandelt wurde.

2. Die konsistente Arbeitsweise der einzelnen Algorithmen durch Aufteilung der Iterationen in Teilarbeiten des einen und die Abschlussarbeiten des anderen, wie bei einer Stabübergabe. Algorithmen sind wie Sportmannschaften, von denen sich jede auf eine bestimmte Phase des Rennens spezialisiert. Die Übergabe des Staffelstabes zwischen ihnen impliziert den Transfer von Wissen und Ergebnissen und schafft einen reibungslosen und effizienten Übergang von einer Phase zur nächsten, wie die Harmonie eines gut eingespielten Teams, wobei die Gesamtzahl der Iterationen unverändert bleibt.

3. Das parallele Arbeiten der einzelnen Algorithmen und die anschließende Kombination der besten Ergebnisse ähnelt der kollektiven Kreativität, bei der jeder Algorithmus ein Künstler ist, der seine einzigartige Energie in die gemeinsame Leinwand der Welt einbringt. Bei jeder Iteration werden die besten Ergebnisse zusammengeführt. Jeder Strich ergänzt und erweitert das Verständnis für das untersuchte Problem und schafft eine gemeinsame Vision der optimalen Lösung.

Diese algorithmischen Hybridisierungsoptionen bieten erhebliche Möglichkeiten für kreative Kombinationen verschiedener Ansätze und Strategien, die zu neuen Entdeckungen und Verbesserungen bei der Optimierung führen. So wie in der Welt der Kunst eine Vielzahl von Stilen und Techniken die Schaffung einzigartiger Werke inspiriert, kann die harmonische Kombination verschiedener Algorithmen zu optimalen Ergebnissen und einer effizienten Erforschung komplexer Probleme führen.

In der Welt der Suche nach optimalen Lösungen, in der jeder Schritt im Raum der Möglichkeiten von Bedeutung ist, ist es wichtig, nicht nur zu suchen, sondern auch mit Vertrauen zu finden, um das gewünschte Ergebnis zu erzielen. Die experimentelle Studie, die wir in einem früheren Artikel im Bereich der Populationsoptimierungsalgorithmen durchgeführt haben, bei der wir die Algorithmen gezwungen haben, sich am globalen Minimalpunkt zu platzieren, um den globalen Maximalpunkt zu erreichen, hat einen wichtigen Aspekt offenbart: die Abhängigkeit des Erfolgs von den Anfangsbedingungen. Einige Algorithmen hatten Schwierigkeiten, den Minimalpunkt zu verlassen, wodurch sie an Effizienz einbüßten, aber andere waren leuchtende Beispiele für universelle Stabilität mit geringer Abhängigkeit von der Ausgangsposition. Einige von ihnen erkundeten den Raum bereits zu Beginn des Prozesses erfolgreich, während andere versuchten, die Ergebnisse in späteren Phasen zu verbessern. Diese einzigartigen Merkmale der einzelnen Algorithmen können erfolgreich genutzt werden, indem ihre positiven Aspekte verstärkt und ihre Nachteile verringert werden. Wir hoffen, dass die Kombination verschiedener Strategien zu effizienteren Methoden führen kann, die den Raum erfolgreich erkunden und die Ergebnisse in verschiedenen Phasen der Arbeit verbessern können. Es ist wichtig hinzuzufügen, dass dank der Standardisierung die Hybridisierung von Algorithmen leichter zugänglich geworden ist. Jetzt sind alle Populationsalgorithmen in einer einzigen Klasse zusammengefasst, was kreative Kombinationen und völlig neue Möglichkeiten eröffnet.

2. Experimentieren mit GWO und COA

Für dieses Experiment nehmen wir zwei Algorithmen, die unterschiedliche Leistungen und Merkmale aufweisen: GWO und COAm. Während GWO ganz unten in der Rangliste steht, befindet sich COAm in der Mitte. Versuchen wir herauszufinden, welche Ergebnisse mit ihren Kombinationen im sequentiellen und parallelen Betrieb erzielt werden können. Wir werden in diesem Artikel nicht auf die Vermischung logischer Elemente von Suchstrategien eingehen, da dies sehr spezifisch für jede Kombination von Algorithmen ist und nicht im Rahmen eines Artikels behandelt werden kann.

Grey Wolf Optimizer (GWO) ist ein metaheuristischer stochastischer Algorithmus, der auf der simulierten Jagd eines Rudels grauer Wölfe basiert.
Hauptmerkmale des GWO-Algorithmus:

• Simulation des Rudelverhaltens. Der Algorithmus verwendet die hierarchische Struktur eines Wolfsrudels, in dem jeder Wolf eine andere Rolle spielt (Alpha, Beta, Delta, Omega).
  
• Suche nach einem globalen Maximum. Alpha-, Beta- und Delta-Wölfe gelten als die anpassungsfähigsten und sind der Beute am nächsten, während die anderen Wölfe dazu neigen, sich ihnen zu nähern. Die GWO steuert rasch auf einen möglichen globalen Extremfall zu.
  
• Anpassungsfähigkeit. Während der Algorithmus arbeitet, ordnen sich die Wölfe ständig neu an und können sich so an veränderte Bedingungen anpassen.
  

Der Kuckucks-Optimierungsalgorithmus (COAm) ist einer der neuesten heuristischen Algorithmen, die von der Natur inspiriert sind. Sie beruht auf dem Parasitismus einiger Kuckucksarten.
Hauptmerkmale des COAm-Algorithmus:

• Simulation des Kuckucksverhaltens. Der Algorithmus basiert auf einer Kuckucksbrutstrategie, bei der der Kuckuck seine Eier in die Nester anderer Vögel legt.
• Suche nach einem globalen Maximum. Die Eier im Nest werden als mögliche Lösungen für das Optimierungsproblem interpretiert, und das Kuckucksei stellt die neue Lösung dar.
  
• Anpassungsfähigkeit. Wenn das Kuckucksei von besserer Qualität ist als das Eltern-Ei, wird es ersetzt. Andernfalls verbleibt das Eltern-Ei im Nest.

Die Hybridisierung dieser Algorithmen wird es also vermutlich ermöglichen, ihre kombinierten Vorteile zu nutzen, um Optimierungsprobleme effizienter zu lösen. Abbildung 1 zeigt ein Sequenzdiagramm des GWO- und COAm-Betriebs. Nach Abschluss der ersten Phase, wenn einige Iterationen dem GWO zugewiesen werden, werden die Zustände der Agenten eines Algorithmus auf einen anderen übertragen. Jeder der Agenten wird in einer neuen Art wiedergeboren (in diesem Fall verwandelt sich der Wolf in einen Kuckuck), wobei die Position der Individuen in der Population erhalten bleibt.

Abbildung 1. Hybrider Algorithmus, GWO+COA

Werfen wir einen Blick auf den wahrscheinlichen Verlauf der Ereignisse:

1. Start:
   - Wir beginnen mit 10.000 Iterationen, was eine begrenzte Ressource ist, sodass jede Iteration entscheidend ist, um die optimale Lösung zu erreichen.
2. Schritt 1 (0 - 5000 Iterationen):
   - Halbieren wir die Gesamtzahl der Iterationen und beginnen mit dem GWO-Algorithmus.
   - Aufgrund der schnellen Ausbreitung der Wölfe im Suchraum konvergieren sie in der Mitte des Zeitraums schnell zu einem möglichen globalen Extremwert.
3. Schritt 2 (5000 - 10000 Iterationen):
   - Nach den ersten 5000 Iterationen passen wir die Position der Wölfe an die Position der Kuckucke an diesen Punkten an.
   - Die Kuckuckssuche mit dem Levy-Flug erhält den Staffelstab, um das Extremum weiter zu verfeinern.
4. Ergebnis:
- Es wird erwartet, dass wir durch diese Kombination von GWO-Algorithmen und Kuckuckssuche mit Levy-Flug in der Lage sein werden, ein genaueres und stabileres globales Extremum in einer begrenzten Anzahl von Iterationen zu erreichen.

Mit dieser Strategie lässt sich die Suche nach einem globalen Extremum in einer begrenzten Anzahl von Iterationen optimieren, sodass ein Gleichgewicht zwischen der Konvergenzgeschwindigkeit und der Genauigkeit des Ergebnisses gewährleistet ist.

Deklarieren wir die Klasse „C_AO_GWO_COAm“, die von der Klasse „C_AO“ abgeleitet wurde. Der Klassenkonstruktor setzt Standardwerte für Optimierungsparameter wie die Populationsgröße „popSize“ und das „Verhältnis“ zwischen den Algorithmen GWO und COAm. Die Klasse wird es ermöglichen, den sequentiellen Betrieb von zwei Algorithmen zu nutzen, während die Handhabung wie gewohnt bleibt und es uns ermöglicht, unseren Prüfstand ohne Änderungen zu nutzen.

Die Klasse definiert auch die Methoden zum Setzen von Parametern (SetParams), zur Initialisierung der Optimierung (Init), zum Verschieben (Moving) und Aktualisieren (Revision) der globalen Lösung und zum Einfügen (Injection) von Koordinatenwerten in Agenten.

Wichtige Variablen in der Klasse sind „ratio“ (das Verhältnis zwischen GWO und COAm) sowie die Klassenobjekte C_AO_GWO und C_AO_COAm zur Implementierung der Optimierungsalgorithmen der Grauen Wölfe bzw. der Kuckucke.

Die Klasse hat auch Variablen, um die Anzahl der Epochen und die aktuelle Epoche für jeden der Algorithmen (GWO und COAm) zu verfolgen.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_GWO_COAm : public C_AO
{
  public: //--------------------------------------------------------------------
  ~C_AO_GWO_COAm () { }
  C_AO_GWO_COAm ()
  {
    ao_name = "GWO_COAm";
    ao_desc = "Grey Wolf Optimizer and Cuckoo Optimization Algorithm M";

    popSize = 50;    //population size
    ratio   = 0.5;   //the ratio of GWO and COAm

    ArrayResize (params, 2);

    params [0].name = "popSize"; params [0].val = popSize;
    params [1].name = "ratio";   params [1].val = ratio;
  }

  void SetParams ()
  {
    popSize = (int)params [0].val;
    ratio   = params      [1].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);

  //----------------------------------------------------------------------------
  double ratio;  //the ratio of GWO and COAm

  private: //-------------------------------------------------------------------
  C_AO_GWO  AO1;
  C_AO_COAm AO2;

  int epochCount;
  int epochNow;

  int epochGWO;
  int epochCOAm;
};
//——————————————————————————————————————————————————————————————————————————————

Die Init-Methode in der Klasse C_AO_GWO_COAm wird zur Initialisierung des Optimierungsprozesses verwendet. Hier werden die Anfangswerte festgelegt, Agenten erstellt und die Initialisierungsparameter für die Algorithmen GWO und COAm eingestellt.

1. Der Erfolg der Standardinitialisierung wird mit der Methode StandardInit überprüft, die anhand der übergebenen Parameter den minimalen und maximalen Suchbereich festlegt.
2. Die Anzahl der Epochen für jeden der Algorithmen GWO und COAm wird auf der Grundlage des „Verhältnisses“ und der Gesamtzahl der Epochen (epochCount) berechnet.
3. Die Parameter für die Algorithmen GWO und COAm werden mit den Methoden SetParams und Init gesetzt und initialisiert.
4. Die Methode gibt „true“ zurück, wenn die Initialisierung erfolgreich war.

Die Methode ermöglicht die anfängliche Einrichtung und Initialisierung der GWO- und COAm-Algorithmen zur Optimierung des Problems mit gegebenen Parametern und Beschränkungen.

//——————————————————————————————————————————————————————————————————————————————
bool C_AO_GWO_COAm::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;

  //----------------------------------------------------------------------------
  epochCount   = epochsP;
  epochNow     = 0;

  epochGWO  = int(epochCount *ratio);
  epochCOAm = epochCount - epochGWO;

  AO1.params [0].val = popSize;
  AO2.params [0].val = popSize;

  AO1.SetParams ();
  AO2.SetParams ();

  AO1.Init (rangeMinP, rangeMaxP, rangeStepP, epochGWO);
  AO2.Init (rangeMinP, rangeMaxP, rangeStepP, epochCOAm);

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

Der Wert der Variablen „epochNow“ erhöht sich im Code der Methode Moving der Klasse C_AO_GWO_COAm um eins. Der „epochNow“-Zähler wird verwendet, um die Phasen zu bestimmen, in denen GWO und dann COAm jeweils arbeiten.

Wenn „epochNow“ kleiner als „epochGWO“ ist, wird die Methode Moving für das Objekt AO1 (GWO) aufgerufen, woraufhin die Elemente des Agentenarrays „AO1.a“ in das Agentenarray „a“ kopiert werden.

Wenn „epochNow“ gleich „epochGWO“ ist, wird die Methode „Moving“ auf dem Objekt „AO2“ (COAm) aufgerufen, und die Werte aus dem Array „AO1.a“ werden dann in die entsprechenden Elemente des Arrays „AO2.a“ eingefügt, d. h. dies ist die eigentliche Umwandlung der Wölfe in Kuckucke. Schließlich werden alle Elemente des Arrays „AO2.a“ in das Array „a“ kopiert, um auf die Agenten „a“ im ausführenden Programm zuzugreifen.

Diese Methode stellt sicher, dass sich die Agenten in jeder Optimierungsepoche in Übereinstimmung mit den gewählten GWO- und COAm-Algorithmen nacheinander bewegen.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO_COAm::Moving ()
{
  epochNow++;

  if (epochNow < epochGWO)
  {
    AO1.Moving ();
    for (int i = 0; i < popSize; i++)
    {
      a [i] = AO1.a [i];
    }
    return;
  }

  AO2.Moving ();

  if (epochNow == epochGWO)
  {
    for (int i = 0; i < popSize; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        AO2.Injection (i, c, AO1.a [i].c [c]);
      }
    }
  }

  for (int i = 0; i < popSize; i++)
  {
    a [i] = AO2.a [i];
  }
}
//——————————————————————————————————————————————————————————————————————————————

Die Revisionsmethode überträgt den berechneten Fitnesswert der Agenten an die entsprechenden Agenten der Algorithmen.

Je nach dem Wert der Variablen „epochNow“ und „epochGWO“ werden die folgenden Aktionen für die Algorithmen GWO oder COAm durchgeführt:

1. Kopieren des Fitnesswerts an Agenten.
2. Ausführen der Methode Revision.
3. Durchführen einer globalen Lösungsaktualisierung.
   

So implementiert die Methode die Logik der Aktualisierung der globalen Lösung mit der Lösung aus den Algorithmen GWO und COAm, je nach dem aktuellen Stand der Ausführung der entsprechenden Algorithmen.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO_COAm::Revision ()
{
  if (epochNow < epochGWO)
  {
    for (int i = 0; i < popSize; i++) AO1.a [i].f = a [i].f;

    AO1.Revision ();

    if (AO1.fB > fB)
    {
      fB = AO1.fB;
      ArrayCopy (cB, AO1.cB, 0, 0, WHOLE_ARRAY);
    }
  }
  else
  {
    for (int i = 0; i < popSize; i++) AO2.a [i].f = a [i].f;

    AO2.Revision ();

    if (AO2.fB > fB)
    {
      fB = AO2.fB;
      ArrayCopy (cB, AO2.cB, 0, 0, WHOLE_ARRAY);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Die Visualisierung der Funktionsweise des hybriden Algorithmus verdeutlicht das folgende Phänomen: GWO bleibt oft in lokalen Extremen stecken und stoppt seine schnelle Bewegung vorzeitig. Im Gegensatz dazu hinterlässt der COA-Algorithmus eine Reihe von unterschiedlichen Ergebnissen, die eine manchmal beeindruckende Bandbreite von Endpunkten ergeben.

GWO-COAm auf der Testfunktion Hilly

GWO-COAm mit der Testfunktion Forest

GWO-COAm auf der Testfunktion Megacity

Daher haben wir in einem Experiment versucht, einen hybriden Algorithmus zu entwickeln, indem wir die Algorithmen GWO und COAm nacheinander kombiniert haben. Dies führte jedoch nicht zu den gewünschten Ergebnissen (Verbesserung der Leistung des besten Bewerbers). GWO bleibt oft in lokalen Maxima stecken und bewegt sich nicht weiter, während der COAm-Algorithmus nicht in der Lage war, den Staffelstab zu übernehmen und durch eine große Streuung der Endergebnisse gekennzeichnet ist, die von der Anzahl der Versuchsdurchläufe abhängt.

Ergebnisse des GWO-COAm-Tests (sequentieller Aufbau):

GWO_COAm|Grauer Wolf Optimierer und Cuckoo Optimierungsalgorithmus M|50.0|0.3|
=============================
5 Hilly's; Func runs: 10000; result: 0.729041499138184
25 Hilly's; Func runs: 10000; result: 0.4465971838522985
500 Hilly's; Func runs: 10000; result: 0.2685674823439256
=============================
5 Forest's; Func runs: 10000; result: 0.6963174902735325
25 Forest's; Func runs: 10000; result: 0.347940898514357
500 Forest's; Func runs: 10000; result: 0.16776831572853218
=============================
5 Megacity's; Func runs: 10000; result: 0.5492307692307692
25 Megacity's; Func runs: 10000; result: 0.2464615384615385
500 Megacity's; Func runs: 10000; result: 0.10724615384615484
=============================
All score: 3.55917 (39.55%)

Das Ergebnis ist vergleichbar mit dem des separaten COAm-Betriebs. Es gibt eine Verbesserung, aber leider ist sie unbedeutend. In einzelnen unabhängigen Läufen liefert COAm jedoch manchmal vergleichbare Ergebnisse.

Versuchen wir, einen Hybrid zu schaffen, der die parallele Arbeit mit dem Austausch der besten Positionen der Agenten bei jeder Iteration zweier Algorithmen kombiniert, die nicht nur unabhängig voneinander arbeiten, sondern auch die besten Lösungen miteinander für ein gemeinsames Ziel austauschen.

Versuchen wir nun, den Parallelbetrieb der Algorithmen GWO und COAm zu nutzen. Dazu müssen wir die Klasse des gemeinsamen Algorithmus praktisch nicht ändern. Ich werde nur den Code der Methoden zur Verfügung stellen, die wesentliche Änderungen erfordern.

Anders als bei der sequenziellen Struktur werden hier die gleitenden Methoden beider Algorithmen gleichzeitig gestartet. Danach kopieren Sie die Agenten dieser Algorithmen in die Agenten der kombinierten Klasse für die anschließende Berechnung der Fitnessfunktion. So kombiniert die Methode die Daten von zwei Objekten „AO1“ und „AO2“ in das aktuelle Objekt-Array „a“.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO_COAm::Moving ()
{
  AO1.Moving ();
  AO2.Moving ();

  int cnt = 0;
  for (int i = 0; i < popSize / 2; i++)
  {
    a [cnt] = AO1.a [i];
    cnt++;
  }

  for (int i = 0; i < popSize / 2; i++)
  {
    a [cnt] = AO2.a [i];
    cnt++;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Die Unterschiede der Moving-Methode für die parallele Operationsstruktur sind wie folgt: Nach der Übertragung von Fitnesswerten an die Objekt-Agenten „AO1“ und „AO2“, der Ausführung ihrer Revisionsmethoden und der Aktualisierung der globalen Lösung werden die Agenten paarweise von einem Algorithmus zum anderen kopiert. Das bedeutet, dass die beiden besten Agenten zwischen den Algorithmen ausgetauscht werden, was beiden Algorithmen hilft, die besten Eigenschaften des jeweils anderen zu bereichern und ihre Leistung bei der Problemlösung zu verbessern. Auf diese Weise können die besten Lösungen, die jeder Algorithmus erzielt hat, gemeinsam genutzt werden.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO_COAm::Revision ()
{
  int cnt = 0;

  for (int i = 0; i < popSize / 2; i++)
  {
    AO1.a [i].f = a [cnt].f;
    cnt++;

    if (AO1.a [i].f > fB)
    {
      fB = AO1.a [i].f;
      ArrayCopy (cB, AO1.a [i].c, 0, 0, WHOLE_ARRAY);
    }
  }

  for (int i = 0; i < popSize / 2; i++)
  {
    AO2.a [i].f = a [cnt].f;
    cnt++;

    if (AO2.a [i].f > fB)
    {
      fB = AO2.a [i].f;
      ArrayCopy (cB, AO2.a [i].c, 0, 0, WHOLE_ARRAY);
    }
  }

  AO1.Revision ();
  AO2.Revision ();
  
  S_AO_Agent temp [];
  ArrayResize (temp, popSize / 2);
  
  for (int i = 0; i < 2; i++) temp [i] = AO1.a [i]; 

  for (int i = 0; i < 2; i++)
  {
    for (int c = 0; c < coords; c++)
    {
      AO1.Injection (i, coords - 1, AO2.a [i].c [c]);
      AO2.Injection (i, coords - 1, temp  [i].c [c]);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Ergebnisse des GWO-COAm-Tests (Parallelstruktur):

GWO_COAm|Grauer Wolf Optimierer und Cuckoo Optimierungsalgorithmus M|50.0|
=============================
5 Hilly's; Func runs: 10000; result: 0.6930620289919492
25 Hilly's; Func runs: 10000; result: 0.4389512737634269
500 Hilly's; Func runs: 10000; result: 0.26733735583025275
=============================
5 Forest's; Func runs: 10000; result: 0.6512995888741085
25 Forest's; Func runs: 10000; result: 0.33119611021722106
500 Forest's; Func runs: 10000; result: 0.16858175021299981
=============================
5 Megacity's; Func runs: 10000; result: 0.4615384615384615
25 Megacity's; Func runs: 10000; result: 0.23015384615384615
500 Megacity's; Func runs: 10000; result: 0.1059538461538471
=============================
All score: 3.34807 (37.20%)

Leider gibt es keine Leistungsverbesserungen.

3. Experimentieren mit ESG und SDSm

Bei den oben beschriebenen GWO- und COAm-Hybridisierungsoptionen wurden Algorithmen aus verschiedenen „Gewichtskategorien“ verwendet. Es ist sinnvoll, Algorithmen zu verwenden, die sich in ihren Fähigkeiten ähneln, damit sie sich wirklich ergänzen. Daher werden wir zwei weitere Experimente mit sequenziellen und parallelen Strukturen durchführen. Um dies zu erreichen, werden wir die Algorithmen ESG und SDSm verwenden.

Durch die Kombination dieser beiden Algorithmen zu einem Hybrid kann eine einzigartige Kombination aus Zufälligkeit und sozialer Dynamik entstehen.

Die stochastische Diffusionssuche (SDSm) ist ein Populationsoptimierungsalgorithmus.

Die wichtigsten Merkmale des Algorithmus:

• Teilweise Bewertung von Lösungen. Die Agenten führen eine partielle Bewertung der Hypothesen (Lösungsvorschläge für das Suchproblem) durch, was die Rechenkomplexität des Algorithmus verringert.
• Verbreitung von vielversprechenden Lösungen. Die Agenten tauschen Informationen über die Hypothesen durch direkte persönliche Kommunikation aus. Qualitativ hochwertige Lösungen können aus Clustern von Agenten mit der gleichen Hypothese ermittelt werden.
• Mathematische Rechtfertigung. SDSm verfügt über eine fundierte mathematische Grundlage, die es zuverlässiger und berechenbarer macht.

SDSm ist ein evolutionäres Optimierungsverfahren, das Zufallssuche und Diffusion kombiniert, um Optimierungsprobleme in hochdimensionalen Räumen zu lösen.

Evolution sozialer Gruppen (ESG) ist ein Optimierungsalgorithmus für mehrere Populationen.

Die wichtigsten Merkmale des Algorithmus:

• Soziale Gruppen. Der Algorithmus arbeitet nicht mit Individuen, sondern mit sozialen Gruppen, die durch Zusammenarbeit und Erfahrungsaustausch verbunden sind. Jede Gruppe hat ihr eigenes Entscheidungszentrum und einen Satz von Partikeln (Mitgliedern) als Optimierungsagenten.
• Kollektive Bewegung. Die „Partikel“ der sozialen Gruppen interagieren und bewegen sich gemeinsam im Parameterraum. Auf diese Weise können die Gruppen verschiedene Regionen des Parameterraums untersuchen und Informationen über die besten gefundenen Lösungen austauschen.
• Lokale und globale Erfahrung. Jede soziale Gruppe speichert Informationen über die beste Lösung innerhalb ihrer Gruppe (lokale Erfahrung). Es gibt auch eine beste Gesamtbewertung unter allen Gruppen (globale Erfahrung).

ESG ist eine einfache Architektur mit hoher Konvergenz und geringen Rechenanforderungen.

Der Code für die Durchführung von Experimenten zum sequentiellen und parallelen Betrieb ist genau derselbe wie oben, außer dass wir die Deklaration der entsprechenden Objekte dieser Klassen anstelle von GWO und COAm ersetzen müssen.

Ergebnisse des ESG-SDSm-Tests (sequentieller Aufbau):

ESG_SDSm|Evolution_von_Sozialen_Gruppen und Stochastische Diffusionssuche M|200.0|0.5|
=============================
5 Hilly's; Func runs: 10000; result: 0.9642488921252973
25 Hilly's; Func runs: 10000; result: 0.7526240638447592
500 Hilly's; Func runs: 10000; result: 0.2961693434072249
=============================
5 Forest's; Func runs: 10000; result: 0.9897783503200446
25 Forest's; Func runs: 10000; result: 0.7608845505131734
500 Forest's; Func runs: 10000; result: 0.2130287247171918
=============================
5 Megacity's; Func runs: 10000; result: 0.82
25 Megacity's; Func runs: 10000; result: 0.5421538461538462
500 Megacity's; Func runs: 10000; result: 0.11932307692307798
=============================
All score: 5.45821 (60.65%)

Ergebnisse des ESG-SDSm-Tests (Parallelstruktur):

ESG_SDSm|Evolution_von_Sozialen_Gruppen und Stochastische Diffusionssuche M|200.0|
=============================
5 Hilly's; Func runs: 10000; result: 0.9561232188424761
25 Hilly's; Func runs: 10000; result: 0.7493199026465321
500 Hilly's; Func runs: 10000; result: 0.3176797705433513
=============================
5 Forest's; Func runs: 10000; result: 0.9726744619317564
25 Forest's; Func runs: 10000; result: 0.7494321306074204
500 Forest's; Func runs: 10000; result: 0.22498291462144127
=============================
5 Megacity's; Func runs: 10000; result: 0.836923076923077
25 Megacity's; Func runs: 10000; result: 0.5261538461538462
500 Megacity's; Func runs: 10000; result: 0.13435384615384738
=============================
All score: 5.46764 (60.75%)

Die Ergebnisse für die sequentiellen und parallelen Hybridisierungsstrukturen erwiesen sich als sehr ähnlich zu den üblichen Fehlern stochastischer Algorithmen. Sie sind geringfügig niedriger als die Ergebnisse der einzelnen Operationen dieser Algorithmen.

4. Zusammenfassung

Die in diesem Artikel als Komponenten für die Hybridisierung betrachteten Algorithmen wurden so ausgewählt, dass sie verschiedene Positionen in der aktuellen Rangliste abdecken und die Auswirkungen der unterschiedlichen Leistung der einzelnen Algorithmen auf das Gesamtergebnis verstehen. Ist es wichtig, dass die Algorithmen in Bezug auf ihre Suchfähigkeit ungefähr gleich sind, um eine ausgewogene Analyse und einen fairen Vergleich ihrer Auswirkungen auf das Endergebnis zu gewährleisten?

In diesem Artikel betrachten wir verschiedene Optimierungsalgorithmen als Komponenten für die Hybridisierung. Unser Ziel ist es, eine breite Palette von Algorithmen abzudecken, die unterschiedliche Positionen in der aktuellen Rangliste einnehmen, um herauszufinden, wie die unterschiedliche Leistung der einzelnen Algorithmen das Gesamtergebnis beeinflusst.

Ob es wichtig ist, dass die Algorithmen in Bezug auf ihre Suchfähigkeit in etwa gleich sind, bleibt eine offene Frage. Das mag keine Rolle spielen, wenn das Hauptziel darin besteht, die beste Lösung zu finden.

Für die Experimente haben wir Algorithmen gewählt, die sich in ihren Fähigkeiten stark unterscheiden, wie GWO und COA. Diese Algorithmen repräsentieren zwei unterschiedliche Optimierungsansätze, aus deren Kombination wir wertvolle Lehren ziehen können. Im Gegensatz dazu haben wir auch Algorithmen ausgewählt, die in ihrer Leistung sehr ähnlich sind, wie ESG und SDSm.

Nachstehend finden Sie die aktuelle Bewertungstabelle der Algorithmen. Sie enthält alle Algorithmen, die wir besprochen haben, und wird aktualisiert, sobald neue Daten verfügbar sind.

Bewertungstabelle der Populationsalgorithmen

Bei dem Versuch, eine hybride Methode zu entwickeln, die parallele Arbeit und den Austausch der besten Positionen der Agenten des ESG- und des SDSm-Algorithmus sowie der sequentiellen Struktur kombiniert, sind wir auf ein zweideutiges Phänomen gestoßen. Im Laufe unserer Forschung haben wir festgestellt, dass die Kombination dieser beiden Ansätze nicht zu Synergie und Verbesserung, sondern zu einem durchschnittlichen Ergebnis geführt hat. Es ist wahrscheinlich, dass die Interaktion zwischen diesen verschiedenen Strategien nicht effizient genug war, was die vollständige Integration ihrer Kernprinzipien verhindert hat.

Bei den Experimenten wurde deutlich, dass sowohl sequentielle als auch parallele Hybridisierungsstrukturen unter diesen Bedingungen nicht zu den gewünschten Ergebnissen führten, was die Bedeutung einer sorgfältigen Auswahl der Algorithmen für eine erfolgreiche Kombination unterstreicht. Es ist notwendig, dass die Algorithmen anfangs bestimmte Eigenschaften haben: entweder sie suchen gut und sind schlecht verfeinert, oder umgekehrt. Nur in diesem Fall können Hybridisierungsmethoden die Leistung der beiden Algorithmen verbessern. Die erfolgreichen Erfahrungen mit der Hybridisierung durch die Fusion der algorithmischen Logik (gemäß der ersten Struktur) verdeutlichen das Potenzial dieses Ansatzes, der jedoch einen nicht trivialen Aufwand, ein sorgfältiges Eingreifen und die Entwicklung einer gemeinsamen Fusionslogik erfordert, um optimale Ergebnisse zu erzielen.

Diese Beobachtung verdeutlicht, wie wichtig nicht nur die einzelnen Merkmale der Algorithmen, sondern auch ihre Interaktionen im Rahmen der Hybridisierung sind. Wie in der Natur, wo die Kombination verschiedener Arten zu einzigartigen Anpassungen führen kann, erfordert auch in der Welt der Optimierung die Kombination von Algorithmen Feinabstimmung und Harmonie. Vielleicht finden wir in unerwarteten Kombinationen und gescheiterten Versuchen die Schlüssel zu neuen Entdeckungen und Verbesserungen auf dem Gebiet der Optimierung.

Diese Erfahrung zeigt, wie wichtig eine sorgfältige Analyse und Auswahl der Algorithmen bei der Entwicklung hybrider Optimierungsmethoden ist. Es ist notwendig, nicht nur die individuellen Eigenschaften der einzelnen Algorithmen zu berücksichtigen, sondern auch ihr Zusammenspiel im Rahmen einer bestimmten Aufgabe, um erfolgreiche Ergebnisse bei der Suche nach optimalen Lösungen zu erzielen.

Probieren, experimentieren, kreieren und kombinieren. Wie immer sind alle Tools und Quellcodes unten beigefügt.