Künstlicher Bienenstock-Algorithmus (ABHA): Theorie und Methoden

Inhalt

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

1. Einführung

In einem der vorangegangenen Artikel haben wir uns bereits mit dem ABC-Algorithmus (Artificial Bee Colony) befasst, der ein bemerkenswertes Beispiel dafür ist, wie die Natur die Entwicklung effizienter Berechnungsmethoden inspiriert. Ein Bienenvolk ist nicht nur eine Gruppe von Insekten, sondern ein hochgradig organisiertes System, in dem jede Biene ihre eigene, einzigartige Aufgabe erfüllt. Einige Bienen werden zu Kundschafterinnen, die die Umgebung auf der Suche nach Nahrung erkunden, während andere die Rolle von Sammlerinnen übernehmen und Nektar und Pollen sammeln. Durch diese Form der Zusammenarbeit kann die Kolonie bei der Suche nach Ressourcen effizienter sein.

Der hier betrachtete neue Algorithmus für künstliche Bienenstöcke (hive) bietet einen umfassenderen und tieferen Einblick in das Futtersuchverhalten der Bienen und zeigt, wie kollektive Interaktion und Rollenzuweisungen die Suche nach neuen Nahrungsquellen (food source) erleichtern. Sie zeigt, wie die Interaktion zwischen den Akteuren zu effizienteren Ergebnissen führen kann. Der Algorithmus nimmt die einzelnen Rollen in einem Bienenvolk genauer unter die Lupe.

Das Hauptziel von ABHA ist es, optimale Lösungen in hochdimensionalen Räumen zu finden, in denen Funktionen viele lokale Minima und Maxima haben können. Dies macht das Optimierungsproblem besonders schwierig, da herkömmliche Methoden an lokalen Extremen hängenbleiben können, ohne das globale Optimum zu erreichen. Der ABHA-Algorithmus orientiert sich an den effizienten Futtersuchstrategien der Bienen. In der Natur nutzen Bienen kollektive Methoden, um effizient Nektarquellen zu finden, und dieses Prinzip wurde angepasst, um einen Algorithmus zu entwickeln, der den Prozess der Suche nach optimalen Lösungen verbessern kann.

Die ABHA-Struktur umfasst verschiedene Zustände, die die Dynamik des Bienenverhaltens widerspiegeln. Ein solcher Zustand ist der „experimentelle Zustand“, in dem die Bienen Informationen über gefundene Nahrungsquellen austauschen. Dieser Zustand fördert die Anhäufung von Wissen über die produktivsten Bereiche des multidimensionalen Raums. Ein weiterer wichtiger Zustand ist der „Suchzustand“ (search state), in dem die Bienen den Raum auf der Suche nach den besten Quellen aktiv erkunden und dabei die von ihren Brüdern erhaltenen Informationen nutzen.

Der künstliche Bienenstock-Algorithmus (Artificial Beehive Algorithm, ABHA) wurde 2009 von einer Gruppe von Forschern unter der Leitung von Andrés Muñoz entwickelt. Es zielt auf die Lösung von kontinuierlichen Optimierungsproblemen ab.

2. Implementierung des Algorithmus

ABHA ist eine interessante Methode, die eine Analogie zum Verhalten von Bienen nutzt, um schwierige Optimierungsprobleme in kontinuierlichen Suchräumen zu lösen. Schauen wir uns die grundlegenden Konzepte des Algorithmus an:

1. Modellierung des Verhaltens von Bienen:

• ABHA basiert auf dem Modell des individuellen Bienenverhaltens. Jeder Agent (Biene) im Algorithmus folgt einer Reihe von Verhaltensregeln, um zu bestimmen, welche Aktionen er durchführen soll.

2. Interaktion innerhalb des Bienenstocks:

• Das Hauptaugenmerk der ABHA liegt auf den Interaktionen zwischen den Bienen.
• Die Bienen tauschen Informationen über die Lösungen aus, die sie gefunden haben.

Der Algorithmus verwendet vier Zustände (Aufgaben) von Bienen, die als verschiedene Arten von Bienenverhalten angesehen werden können. Aus Gründen der Übersichtlichkeit ist es zweckmäßig, diese Zustände in Form einer Tabelle darzustellen:

Bienenstaat	Arten von Verhalten
Neuling	Sie befindet sich in einem „Bienenstock“ (einer abstrakten Position, in der Informationen ausgetauscht werden) und hat keine Informationen über Nahrungsquellen.
Erfahren	Sie hat Informationen über die Nahrungsquelle und kann sie weitergeben.
Sucher	Sucht nach einer besseren Nahrungsquelle als der jetzigen.
Nahrungsquelle	Bewertet die Profitabilität seiner Nahrungsquelle und entscheidet, ob es sich lohnt, sie anzumelden.

Jeder dieser Zustände spiegelt verschiedene Aspekte des Verhaltens der Bienen bei der Suche nach und der Nutzung von Nahrungsquellen wider. Jeder Zustand einer Biene steht für eine Reihe von Regeln, denen die entsprechende Biene folgt:

Bienenstaat	Regeln für die Veränderung der Position einer Biene im Raum
Neuling	Die Biene kann eine zufällige Suche einleiten oder einem Tanz (bee dance) folgen, wenn ein solcher vorhanden ist. Wenn keine Informationen über die Nahrungsquelle verfügbar sind, kann er eine zufällige Suche starten.
Erfahren	Wenn die Informationen über eine Nahrungsquelle gültig sind, kann eine Biene sie durch Tanzen an andere Bienen weitergeben. Wenn die Informationen ungültig sind, wird möglicherweise eine Zufallssuche gestartet.
Sucher	Eine Biene ändert ihre Position anhand von Informationen über Richtung und Schrittweite, bis sie die beste Futterquelle gefunden hat.
Nahrungsquelle	Eine Biene bewertet die Profitabilität einer Quelle und kann, wenn sie die Kriterien nicht erfüllt, die Richtung der Suche ändern.

Nicht alle Bienen können Informationen über eine Nahrungsquelle weitergeben, und nicht jede Biene kann Informationen von anderen Bienen erhalten, die diese Fähigkeit besitzen. Es gibt zwei Arten von Bienen, die die Fähigkeit haben, Informationen über eine Nahrungsquelle zu empfangen oder weiterzugeben:

1. Die Fähigkeit, Informationen weiterzugeben:

• Erfahren – gibt Informationen an andere Bienen durch Tanz weiter, wenn die Informationen über die Nahrungsquelle gültig sind.

2. Die Fähigkeit, Informationen durch den Tanz anderer Bienen zu erhalten:

• Anfänger – kann einem Tanz folgen, falls vorhanden, um Informationen über Nahrungsquellen zu erhalten.
• Erfahren – ist in der Lage, durch Tanzen Informationen von anderen Bienen zu erhalten und hat Zugang zu Informationen über Nahrungsquellen.

Bienen können ihren Zustand in Abhängigkeit von ihren Erfahrungen und Informationen über Nahrungsquellen ändern. Im Folgenden werden die Bienenarten und die Bedingungen, unter denen sie von einem Zustand in einen anderen übergehen können, aufgeführt:

1. Neuling

• In Erfahren: Erhält ein Neuling Informationen über eine hochprofitable Nahrungsquelle (z. B. durch Tänze anderer Bienen), kann er in den erfahrenen Zustand übergehen.
• In Sucher: Wenn ein Neuling keine Informationen über Nahrungsquellen erhält, kann er von sich aus auf die Suche gehen und sich in einen Suchzustand begeben.

2. Erfahren

• In Sucher: Wenn die Informationen über die aktuelle Nahrungsquelle nicht ausreichen (z. B. wenn der aktuelle Fitnesswert unter dem Schwellenwert liegt), kann eine Biene in einen Suchzustand übergehen und nach neuen Quellen suchen.
• In Nahrungsquelle: Wenn die Informationen über eine Nahrungsquelle bestätigt werden (z. B. wenn der aktuelle Fitnesswert hoch und stabil ist), kann eine Biene in einen Nahrungsquellenstatus wechseln, um die Quelle eingehender zu analysieren.

3. Sucher

• In Nahrungsquelle: Findet eine suchende Biene eine Nahrungsquelle mit guten Eigenschaften (z. B. ist der aktuelle Fitnesswert besser als der Schwellenwert), kann sie in den Zustand der Nahrungsquelle wechseln, um die Profitabilität der Quelle regelmäßig zu bewerten.
• In Anfänger. Wenn eine suchende Biene keine Nahrungsquellen findet oder die Informationen nicht wertvoll genug sind, kann sie zur Anfängerin zurückkehren.

4. Nahrungsquelle

• In Sucher: Wenn sich die aktuelle Nahrungsquelle als unpraktisch erweist (z. B. wenn der aktuelle Fitnesswert schlechter ist als der Schwellenwert), kann eine Biene in einen Suchzustand wechseln, um nach neuen Quellen zu suchen.
• In Erfahren: Wenn eine Biene eine Nahrungsquelle (Food source) findet, die sich als vorteilhaft erweist, kann sie sich in einen erfahrenen Zustand versetzen, um die Informationen an andere Bienen weiterzugeben.

Diese Zustandsübergänge ermöglichen es dem Algorithmus, seine Suchstrategie in Abhängigkeit von der Position der Individuen im Lösungsraum dynamisch zu ändern und Informationen über Nahrungsquellen effizient auszutauschen.

Die Begriffe „Nahrungsquelle“ und „Bienentanz“ spielen im Algorithmus eine wichtige Rolle. Im Zusammenhang mit dem Algorithmus stellt eine „Nahrungsquelle“ eine potenzielle Lösung für das Optimierungsproblem dar:

1. Jede „Nahrungsquelle“ entspricht einer bestimmten Position, die eine mögliche Lösung des Optimierungsproblems im Suchraum darstellt. 
2. Die Qualität oder „Profitabilität“ einer Nahrungsquelle wird durch den Wert der Zielfunktion an diesem Punkt bestimmt. Je höher der Wert der Zielfunktion, desto „profitabler “ ist die Nahrungsquelle.
3. Die Bienen im Algorithmus suchen und nutzen die „profitabelsten“ Nahrungsquellen – Positionen, die den besten Werten der Zielfunktion entsprechen.
4. Die Erschöpfung einer Nahrungsquelle bedeutet, dass an einem bestimmten Punkt im Suchraum keine bessere Lösung gefunden werden kann, und die Bienen sollten sich auf die Suche nach neuen, vielversprechenderen Gebieten begeben.

In dem Algorithmus ist ein „Tanz“ eine Möglichkeit für die Bienen, Informationen über die gefundenen „Nahrungsquellen“ auszutauschen. Das geschieht folgendermaßen:

• Wenn eine Biene eine vielversprechende „Nahrungsquelle“ findet, kehrt sie in einen „Bienenstock“ zurück und führt einen „Tanz“ auf.
• Die Dauer eines „Tanzes“ hängt von der „Profitabilität“ einer gefundenen Nahrungsquelle ab, je besser die Lösung, desto länger „tanzt“ sie.
  
• Andere Bienen im Bienenstock können diesen „Tanz“ hören und so Informationen über die Nahrungsquelle erhalten. Die Wahrscheinlichkeit, dass eine Biene dem „Tanz“ folgt, hängt von der „Profitabilität“ der Quelle ab.

So ist eine „Futterquelle“ im ABHA-Algorithmus ein Analogon einer potenziellen Lösung für ein Optimierungsproblem, während ihre „Profitabilität“ durch den Wert der Zielfunktion an dem entsprechenden Punkt im Suchraum bestimmt wird, und ein „Tanz“ ist eine Möglichkeit, Informationen zwischen den Bienen über die vielversprechendsten Lösungen, die während der Suche gefunden wurden, weiterzugeben.

Im ABHA-Algorithmus verwendet jede Bienenart die Fitness- (oder Kosten-) Werte des vorherigen Schritts, des aktuellen Schritts und den besten Fitnesswert wie folgt:

Bienenstaat	Neuling	Erfahren	Sucher	Nahrungsquelle
Laufende Kosten	Wird verwendet, um entweder den Status „Erfahren“ oder „Sucher“ einzugeben.	Wenn der aktuelle Wert hoch ist und die Information gültig ist, kann sie diese Information durch einen Tanz an andere Bienen weitergeben.	Eine Biene nutzt ihren aktuellen Fitnesswert, um ihre aktuelle Position zu bewerten und zu entscheiden, ob sie die Suche fortsetzt oder die Richtung ändert.	Liegt der aktuelle Wert unter dem Schwellenwert, kann es zu dem Schluss kommen, dass die Quelle nicht gut genug ist, und sich auf die Suche nach einer neuen Quelle machen.
Vorheriger Wert	Nicht verwendet	Eine Biene vergleicht den aktuellen Wert mit dem vorherigen, um festzustellen, ob sich die Situation verbessert hat. Wenn der aktuelle Wert besser ist, kann er die Wahrscheinlichkeit der Weitergabe der Information erhöhen.	Eine Biene vergleicht den aktuellen Wert mit dem vorherigen, um festzustellen, ob sich die Situation verbessert hat. Wenn der aktuelle Wert besser ist, kann er sich in dieselbe Richtung entwickeln.	Nicht verwendet
Bester Wert	Nicht verwendet	Anhand des besten Wertes kann eine Biene beurteilen, ob sie eine bestimmte Nahrungsquelle weiter erforschen oder eine neue suchen soll.	Die Biene verwendet den besten Wert, um festzustellen, ob die aktuelle Nahrungsquelle profitabler ist. Dies hilft ihm bei der Entscheidung, ob er an Ort und Stelle bleiben oder weiter suchen soll.	Anhand des besten Wertes entscheidet die Biene, ob sie die aktuelle Nahrungsquelle weiter ausbeutet oder in den erfahrenen Zustand wechselt.

Jede Bienenart nutzt die Informationen über die Fitness bei verschiedenen Iterationen, um Entscheidungen zu treffen und in verschiedene Zustände überzugehen.

In dem Algorithmus werden die Wahrscheinlichkeiten für die Aktionsauswahl, wie die Wahrscheinlichkeit einer zufälligen Suche, die Wahrscheinlichkeit, einem Tanz zu folgen, und die Wahrscheinlichkeit, die Quelle zu verlassen (oder in der Nähe der Quelle zu bleiben), während der Optimierung dynamisch berechnet. Diese Wahrscheinlichkeiten helfen den Agenten (Bienen) dabei, auf der Grundlage der aktuellen Informationen und des Zustands der Umgebung Entscheidungen über ihr Handeln zu treffen.

Berechnung von Wahrscheinlichkeiten:

1. Wahrscheinlichkeit der zufälligen Suche (Psrs): Die Wahrscheinlichkeit, dass eine Biene eine zufällige Suche beginnt, anstatt einem Tanz zu folgen oder bei der aktuellen Nahrungsquelle zu bleiben.

2. Wahrscheinlichkeit, einem Tanz zu folgen (Prul): Die Wahrscheinlichkeit, dass eine Biene dem Tanz einer anderen Biene folgt.

3. Wahrscheinlichkeit des Verlassens einer Quelle (Pab): Die Wahrscheinlichkeit, dass eine Biene in der Nähe der aktuellen Nahrungsquelle verbleibt oder diese verlässt.

Bienen in verschiedenen Staaten verwenden Wahrscheinlichkeiten unterschiedlich, und die Wahrscheinlichkeiten für jeden Staat sind ebenfalls unterschiedlich:

1.  Neuling:

• Psrs: hoch, da eine Biene keine Informationen über andere Quellen hat und eine zufällige Suche starten kann.
• Prul: kann verwendet werden, wenn andere Bienen tanzen, aber die Wahrscheinlichkeit hängt von den verfügbaren Informationen ab.
• Pab: nicht anwendbar, da die Biene noch keine Nahrungsquelle gefunden hat.

2. Erfahren:

• Psrs: gering, da die Biene bereits Informationen über die Quelle hat.
• Prul: wird verwendet, um Informationen an andere Bienen weiterzugeben, wenn die Quellinformation als gültig angesehen wird.
• Pab: kann verwendet werden, um zu entscheiden, ob eine aktuelle Quelle weiter erforscht oder aufgegeben werden soll, wenn ihr Gewinn gering ist.

 3. Sucher:

• Psrs: kann verwendet werden, wenn die Biene keine zufriedenstellenden Quellen findet.
• Prul: kann verwendet werden, wenn eine Biene beschließt, dem Tanz einer anderen Biene zu folgen, um eine neue Quelle zu finden.
• Pab: wird verwendet, um zu entscheiden, ob die Suche fortgesetzt oder zum „Bienenstock“ zurückgekehrt werden soll.

 4. Nahrungsquelle:

• Psrs: niedrig, weil die Biene die Quelle bereits gefunden hat.
• Prul: wird verwendet, um Informationen über eine gültige Quelle an andere Bienen weiterzugeben, wenn die Quelle als profitabel angesehen wird.
• Pab: hoch, wenn die Quelle keine zufriedenstellenden Ergebnisse liefert, was zu einer Entscheidung führen kann, sie aufzugeben.

Hoffentlich habe ich alle Nuancen des Bienenverhaltens abgedeckt und kann nun mit dem Schreiben von Pseudocode beginnen.

Initialisierung:
    Algorithmus-Parameter festlegen (popSize, maxSearchAttempts, abandonmentRate, usw.)
    Erstellen einer Population von popSize-Agenten mit zufälligen Positionen
    Setzen des Ausgangszustands von jedem Agenten auf Neuling

Hauptschleife:
    Bis zum Erreichen der Anhaltebedingung:
        Für jeden Agenten:
            Durchführen einer Aktion in Abhängigkeit vom aktuellen Status:
                Neuling: Zufällige Suche oder dem Tanz folgen
                Erfahren: Zufällige Suche, nach einem Tanz oder lokale Suche
                Suche: Bewegung in eine bestimmte Richtung
                Nahrungsquelle suchen: Lokale Suche um die beste Position
            
            Bewertung der Eignung von Agenten
            Aktualisieren der beste globalen Lösung, falls gefunden

        Berechnung von Wahrscheinlichkeiten und durchschnittlichen Kosten von Entscheidungen

        Für jeden Agenten:
            Status aktualisieren:
                Neuling: Übergang zu Erfahren oder Sucher
                Erfahren: möglicher Übergang zu Nahrungsquelle oder Sucher
                Suche: möglicher Übergang zu Neuling oder Nahrungsquelle
                Nahrungsquelle: möglicher Übergang zu Sucher oder Erfahren

            Aktualisieren der besten, persönlichen Position und des besten Wertes

    Berechnung der Wahrscheinlichkeiten der Agenten
    Berechnung der Durchschnittskosten

Beginnen wir nun mit dem Schreiben des Algorithmus-Codes. Die ABHA-Logik ist recht komplex und der Code ist umfangreich, daher werden wir die Struktur, die Klasse und die Methoden, die an der Arbeit beteiligt sind, so detailliert wie möglich beschreiben.

Die Struktur S_ABHA_Agent stellt den „Bienen“-Agenten im Algorithmus auf der Grundlage des Bienenverhaltens dar. Struktur:

1. Die Enumeration BeeState definiert die verschiedenen Zustände der Biene:

• stateNovice - Neulingsstatus, wenn eine Biene gerade erst mit ihrer Tätigkeit beginnt.
• stateExperienced - erfahrener Zustand, wenn bereits einige Erfahrungen gesammelt wurden.
• stateSearch - der Suchzustand, wenn die Biene aktiv nach Futterquellen sucht.
• stateSource - der Zustand in der Nähe der Quelle und ihre periodische Bewertung.
  

2. Die Felder der Struktur:

• position [] - Array der aktuellen Position der Biene im Raum.
• bestPosition [] - Array der gefundenen besten Bienenposition.
• direction [] - Array für die Bewegungsrichtung der Bienen.
• Kosten - aktuelle Qualität der Nahrungsquelle.
• prevCost - frühere Qualität der Nahrungsquelle.
• bestCost - Qualität der besten, gefundenen Nahrungsquelle.
• stepSize - Verhältnis der Schrittweite bei der Bewegung entlang der Koordinaten.
• state - aktueller Zustand einer Biene, dargestellt als Ganzzahl.
• searchCounter - Zähler der Bienenaktionen im Suchzustand.

3. Felder der Struktur, die die Wahrscheinlichkeiten festlegen:

• pab - Wahrscheinlichkeit, in der Nähe der Nahrungsquelle zu bleiben.
• p_si - dynamische Wahrscheinlichkeit, dass andere Bienen den Tanz dieser Biene wählen.
• p_srs - zufällige Suchwahrscheinlichkeit.
• p_rul - Wahrscheinlichkeit, dem Tanz zu folgen.
• p_ab - Wahrscheinlichkeit, sich in der Nähe der Nahrungsquelle aufzuhalten.

4. Init-Methode:

• Initialisieren des Agenten, indem die Anzahl der Koordinaten und die anfängliche Schrittweite initStepSize übernehmen.
• Die Methode weist den Arrays Speicher zu und setzt Anfangswerte für alle Elemente der Struktur, einschließlich Status, Zähler und Wahrscheinlichkeiten.

Die Struktur S_ABHA_Agent wird verwendet, um das Verhalten einer Biene in einem Algorithmus zu modellieren, wobei die Biene verschiedene Zustände annehmen, den Raum auf der Suche nach Nahrung erkunden und mit anderen Bienen interagieren kann. Die Initialisierung einer Struktur ermöglicht es uns, die für den Start des Algorithmus erforderlichen Anfangsparameter festzulegen.

//——————————————————————————————————————————————————————————————————————————————
struct S_ABHA_Agent
{
    enum BeeState
    {
      stateNovice      = 0,    // Novice state
      stateExperienced = 1,    // Experienced state
      stateSearch      = 2,    // Search state
      stateSource      = 3     // Food source state
    };

    double position        []; // Current position of the bee
    double bestPosition    []; // Best bee position found
    double direction       []; // Bee movement direction vector
    double cost;               // Current food source quality
    double prevCost;           // Previous food source quality
    double bestCost;           // Best food source found quality
    double stepSize;           // Step ratio in all coordinates during a bee movement
    int    state;              // Bee's current state
    int    searchCounter;      // Counter of the bee actions in the search state

    double pab;                // Probability of remaining near the source
    double p_si;               // Dynamic probability of other bees choosing this bee's dance

    double p_srs;              // Random search probability
    double p_rul;              // Probability of following the dance
    double p_ab;               // Probability of source rejection

    void Init (int coords, double initStepSize)
    {
      ArrayResize (position,        coords);
      ArrayResize (bestPosition,    coords);
      ArrayResize (direction,       coords);
      cost              = -DBL_MAX;
      prevCost          = -DBL_MAX;
      bestCost          = -DBL_MAX;
      state             = stateNovice;
      searchCounter     = 0;
      pab               = 0;
      p_si              = 0;
      p_srs             = 0;
      p_rul             = 0;
      p_ab              = 0;

      stepSize        = initStepSize;
    }
};
//——————————————————————————————————————————————————————————————————————————————

Die Klasse C_AO_ABHA wird von der Basisklasse C_AO abgeleitet, was bedeutet, dass sie die in der übergeordneten Klasse definierten Funktionen verwendet. Beschreibung der Klasse:

1. Der Konstruktor C_AO_ABHA ():

• Er legt Parameter wie die Populationsgröße (popSize), die maximale Anzahl von Suchversuchen (maxSearchAttempts), die Verhältnisse für verschiedene Wahrscheinlichkeiten und die anfängliche Schrittweite (initialStepSize) fest.
• Er initialisiert das Array params, das die Algorithmusparameter enthält.

2. Die Methode SetParams () setzt die Werte der Algorithmusparameter auf der Grundlage der im Array params gespeicherten Werte.

3. Die Methode Init () initialisiert den Algorithmus, indem sie die minimalen und maximalen Werte des Suchbereichs, den Suchschritt und die Anzahl der Epochen als Eingaben übernimmt. 

4. Die Methoden Moving () und Revision () dienen dazu, die Logik der Bewegung von Agenten (Bienen) zu implementieren und die gefundenen Lösungen zu revidieren.

5. Mitglieder der Klasse:

• maxSearchAttempts - maximale Anzahl von Suchversuchen.
• abandonmentRate - schrittweise Änderung der Wahrscheinlichkeit, in der Nähe der Nahrungsquelle zu bleiben.
• randomSearchProbability - Zufalls-Suchwahrscheinlichkeit.
• stepSizeReductionFactor - Verkleinerungsfaktor der Schrittweite.
• initialStepSize - anfängliche Schrittweite.
• S_ABHA_Agent agents [] - Array von Agenten (Bienen), die an dem Algorithmus teilnehmen.
• avgCost - durchschnittliche Kosten der gefundenen Lösung.

6. Methoden für die Aktionen der Bienen:

• ActionRandomSearch () - zufällige Suche in einem bestimmten Bereich.
• ActionFollowingDance () - dem Tanz einer anderen Biene folgen.
• ActionMovingDirection () - Bewegung in eine bestimmte Richtung unter Berücksichtigung der Schrittweite.
• ActionHiveVicinity () - Bewegung in der Nähe einer Nahrungsquelle.

7. Methoden für die Aktivität der Bienen in verschiedenen Staaten: StageActivityNovice (), StageActivityExperienced (), StageActivitySearch (), StageActivitySource () bestimmen die Aktionen der Bienen je nach ihrem Zustand.

8. Die Methoden zur Veränderung des Bienenstaates: ChangingStateForNovice (), ChangingStateForExperienced (), ChangingStateForSearch (), ChangingStateForSource () verändern den Zustand der Bienen je nach ihrer Aktivität.

9. Berechnungsmethoden:

• CalculateProbabilities () - Berechnung der Wahrscheinlichkeiten für die Aktionen der Bienen.
• CalculateAverageCost () - Berechnung der durchschnittlichen Kosten der gefundenen Lösungen.

Die Klasse C_AO_ABHA implementiert einen Optimierungsalgorithmus, der auf dem Verhalten der Bienen basiert und verschiedene Aspekte der Aktionen der Bienen, wie Bewegung, Entscheidungsfindung und Zustandsänderungen, abdeckt.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_ABHA : public C_AO
{
  public:
  C_AO_ABHA ()
  {
    ao_name = "ABHA";
    ao_desc = "Artificial Bee Hive Algorithm";
    ao_link = "https://www.mql5.com/en/articles/15347";

    popSize                 = 10;

    maxSearchAttempts       = 10;
    abandonmentRate         = 0.1;
    randomSearchProbability = 0.1;
    stepSizeReductionFactor = 0.99;
    initialStepSize         = 0.5;

    ArrayResize (params, 6);
    params [0].name = "popSize";                 params [0].val = popSize;

    params [1].name = "maxSearchAttempts";       params [1].val = maxSearchAttempts;
    params [2].name = "abandonmentRate";         params [2].val = abandonmentRate;
    params [3].name = "randomSearchProbability"; params [3].val = randomSearchProbability;
    params [4].name = "stepSizeReductionFactor"; params [4].val = stepSizeReductionFactor;
    params [5].name = "initialStepSize";         params [5].val = initialStepSize;
  }

  void SetParams ()
  {
    popSize                 = (int)params [0].val;

    maxSearchAttempts       = (int)params [1].val;
    abandonmentRate         = params      [2].val;
    randomSearchProbability = params      [3].val;
    stepSizeReductionFactor = params      [4].val;
    initialStepSize         = params      [5].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 ();

  //----------------------------------------------------------------------------
  int    maxSearchAttempts;
  double abandonmentRate;
  double randomSearchProbability;
  double stepSizeReductionFactor;
  double initialStepSize;

  S_ABHA_Agent agents [];

  private: //-------------------------------------------------------------------
  double avgCost;

  //Types of bees' actions----------------------------------------------------------
  double ActionRandomSearch       (int coordInd);                      //1. Random search (random placement in a range of coordinates)
  double ActionFollowingDance     (int coordInd, double val);          //2. Follow the dance (move in the direction of the dancer)
  double ActionMovingDirection    (S_ABHA_Agent &agent, int coordInd); //3. Move in a given direction with a step
  double ActionHiveVicinity       (int coordInd, double val);          //4. Move in the vicinity of a food source

  //Actions of bees in different states----------------------------------------
  void   StageActivityNovice      (S_ABHA_Agent &agent); //actions 1 or 2
  void   StageActivityExperienced (S_ABHA_Agent &agent); //actions 1 or 2 or 4
  void   StageActivitySearch      (S_ABHA_Agent &agent); //actions 3
  void   StageActivitySource      (S_ABHA_Agent &agent); //actions 4

  //Change bees' state----------------------------------------------------
  void ChangingStateForNovice      (S_ABHA_Agent &agent);
  void ChangingStateForExperienced (S_ABHA_Agent &agent);
  void ChangingStateForSearch      (S_ABHA_Agent &agent);
  void ChangingStateForSource      (S_ABHA_Agent &agent);

  void CalculateProbabilities ();
  void CalculateAverageCost   ();
};
//——————————————————————————————————————————————————————————————————————————————

Die Methode Init der Klasse C_AO_ABHA ist für die Initialisierung des ABHA-Algorithmus zuständig. Schlüsseln wir das Stück für Stück auf:

1. Parameter der Methode:

• rangeMinP [] - Array der minimalen Suchbereichswerte. Dies sind die Untergrenzen für jede Variable, die optimiert werden soll.
• rangeMaxP [] - Array der maximalen Suchbereichswerte. Dies sind die Obergrenzen für jede Variable.
• rangeStepP [] - Suchschritt-Array. Diese Werte bestimmen, wie stark sich die Variablen während der Suche verändern.
• epochsP - Anzahl der Epochen (Iterationen), die der Algorithmus durchläuft. 

2. Die Methode gibt „true“ zurück, wenn die Initialisierung erfolgreich war, andernfalls „false“.

Die Logik der Methode:

• Aufruf der Methode StandardInit mit Suchbereichsparametern. Diese Methode führt Standardinitialisierungsvorgänge wie das Festlegen von Suchgrenzen und Schritten durch. Wenn die Initialisierung fehlschlägt, bricht die Methode Init die Ausführung ab und gibt „false“ zurück.
• Die Methode ArrayResize ändert die Größe des Arrays „agents“, das die Bienen (Agenten) im Algorithmus darstellt. Die Array-Größe wird auf popSize gesetzt, was die Anzahl der an der Optimierung beteiligten Agenten bestimmt.
• Die Schleife initialisiert jeden Agenten in dem Array „agents“. Die Methode Init wird für jeden Agenten aufgerufen, die seine Anfangskoordinaten (aus dem Array „coords“) und die anfängliche Schrittweite (initialStepSize) festlegt. In diesem Schritt wird festgelegt, wie weit sich der Agent während der Suche bewegen kann.

Die Methode Init der Klasse C_AO_ABHA erfüllt die folgenden Aufgaben:

• Sie prüft, ob die Standardinitialisierung der Suchparameter erfolgreich war.
• Sie ändert die Größe des Agentenfeldes entsprechend der angegebenen Anzahl von Bienen.
• Sie initialisiert jeden Agenten mit seiner eigenen Init-Methode, die die Anfangsparameter festlegt, die für das Funktionieren des Algorithmus erforderlich sind.

Wenn alle Schritte erfolgreich abgeschlossen sind, gibt die Methode „true“ zurück, was die erfolgreiche Initialisierung des Algorithmus anzeigt.

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

  ArrayResize (agents, popSize);
  for (int i = 0; i < popSize; i++)
  {
    agents [i].Init (coords, initialStepSize);
  }
  return true;
}
//————————————————————

Als Nächstes folgt die Methode Moving der Klasse C_AO_ABHA, die die Bewegungsphase des Agenten im Algorithmus implementiert. Die Methode Moving benötigt keine Parameter und gibt keinen Wert zurück. Sie steuert die Bewegung der Agenten (Bienen) während der Optimierung. Die Logik der Methode:

1. Erste Initialisierung.

• Überprüfung der Revisionsvariable. Wenn „false“, ist dies der erste Methodenaufruf und die Agentenpositionen sollten initialisiert werden.
• Generierung von Anfangspositionen - verschachtelte Schleifen iterieren über alle Agenten und Koordinaten. Für jede Koordinate:
• Erzeugt den Zufallswert val innerhalb des angegebenen Bereichs (rangeMin und rangeMax).
• Dieser Wert wird dann mit Hilfe der SeInDiSp angepasst, die den Wert auf den zulässigen Bereich mit dem angegebenen Schritt einstellt.
• Die aktuelle Position und die beste Position des Agenten werden festgelegt (zu Beginn sind sie identisch).
• Es wird eine zufällige Bewegungsrichtung des Agenten generiert.
• Nach Abschluss der Initialisierung wird revision auf „true“ gesetzt und die Methode beendet.

2. Die grundlegende Logik der Agentenbewegung. Umzugshelfer nach Staaten:

• Der aktuelle Zustand jedes Agenten (Anfänger, Erfahrener, Sucher oder Nahrungsquelle) wird durch Umschalten bestimmt. Je nach Zustand wird die entsprechende Methode aufgerufen, die das Verhalten des Agenten steuert (z. B. StageActivityNovice, StageActivityExperienced usw.).
• Nach der Durchführung von Aktionen, die vom Zustand abhängen, werden die Positionen der Agenten mit Hilfe der SeInDiSp aktualisiert, um innerhalb akzeptabler Grenzen zu bleiben.

3. Die Schleife aktualisiert das Array a und kopiert die aktuellen Positionen der Agenten in die entsprechenden Elemente des Arrays a.

Die endgültige Bedeutung der Methode Moving, die die Bewegung der Agenten im ABHA-Algorithmus steuert. Sie initialisiert zunächst die Positionen der Agenten, wenn dies der erste Methodenaufruf ist, und aktualisiert dann ihre Positionen in Abhängigkeit von ihrem Zustand und ihren Einschlüssen:

• Generierung zufälliger Startpositionen.
• Bestimmung des Verhaltens von Agenten in Abhängigkeit von ihrem Zustand.
• Aktualisierung der aktuellen Positionen der Agenten im Array a. 

Diese Methode ist die Schlüssel- und Kontrollmethode für den Aufruf anderer Bienenstatusmethoden für das dynamische Verhalten von Agenten im Optimierungsprozess.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ABHA::Moving ()
{
  //----------------------------------------------------------------------------
  if (!revision)
  {
    double val = 0.0;

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

        agents [i].position     [c] = val;
        agents [i].bestPosition [c] = val;
        agents [i].direction    [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c]));

        a [i].c [c] = val;
      }
    }
    revision = true;
    return;
  }
  //----------------------------------------------------------------------------
  for (int i = 0; i < popSize; i++)
  {
    switch (agents [i].state)
    {
      //------------------------------------------------------------------------
      //Novice
      case S_ABHA_Agent::stateNovice:
      {
        StageActivityNovice (agents [i]);
        break;
      }
        //------------------------------------------------------------------------
        //Experienced
      case S_ABHA_Agent::stateExperienced:
      {
        StageActivityExperienced (agents [i]);
        break;
      }
        //------------------------------------------------------------------------
        //Search
      case S_ABHA_Agent::stateSearch:
      {
        StageActivitySearch (agents [i]);
        break;
      }
        //------------------------------------------------------------------------
        //Food source
      case S_ABHA_Agent::stateSource:
      {
        StageActivitySource (agents [i]);
        break;
      }
    }
    //--------------------------------------------------------------------------
    for (int c = 0; c < coords; c++)
    {
      agents [i].position [c] = u.SeInDiSp (agents [i].position [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      a      [i].c        [c] = agents [i].position [c];
    }
  }
  for (int i = 0; i < popSize; i++) for (int c = 0; c < coords; c++) a [i].c [c] = agents [i].position [c];
}
//——————————————————————————————————————————————————————————————————————————————

Die Methode Revision der Klasse C_AO_ABHA ist für die Aktualisierung des Zustands der Agenten im Algorithmus zuständig und führt mehrere wichtige Aktionen im Zusammenhang mit der Bewertung und Aktualisierung der Positionen und Zustände der Agenten durch. Die Methode Revision benötigt keine Parameter und gibt keine Werte zurück. Es dient der Aktualisierung von Informationen über den Status der Agenten und ihrer Positionen auf der Grundlage ihrer Leistung. Die Logik der Methode:

1. Die Suche nach dem besten Agenten:

• Die Variable ind wird mit dem Wert -1 initialisiert, um den Agentenindex mit den besten Kosten zu verfolgen.
• Bei der Suche nach dem besten Agenten durchläuft der Zyklus alle Agenten popSize:
• Wenn die Kosten des Agenten a [i].f das aktuelle Maximum von fB überschreiten, wird fB aktualisiert und der Index ind gespeichert.
• Wenn der Agent mit den besten Kosten (ind ist ungleich -1) gefunden wird, wird die Funktion ArrayCopy aufgerufen, die die Koordinaten des besten Agenten in das Array cB kopiert.

2. Der Zyklus durchläuft alle Agenten und aktualisiert ihre agents[i].cost Kosten auf der Grundlage der Werte des Arrays a.

3. Die Methode CalculateProbabilities, die die Wahrscheinlichkeiten für jeden Agenten auf der Grundlage seiner aktuellen Kosten berechnet, wird aufgerufen. Auf diese Weise wird festgelegt, wie die Agenten im nächsten Schritt handeln werden.

4. Die Methode CalculateAverageCost wird ebenfalls aufgerufen. Es berechnet die durchschnittlichen Kosten aller Agenten, die die Bienen benötigen, um ihren eigenen Zustand zu analysieren und neue Zustände anzusteuern.

5. Der Zyklus durchläuft alle Agenten und ruft die entsprechende Methode zur Änderung des Agentenstatus auf, je nachdem, ob es sich um ChangingStateForNovice, ChangingStateForExperienced usw. handelt.

6. Der Zyklus geht durch alle Agenten und prüft, ob der aktuelle Wert des Agenten größer ist als sein bester bestCost:

• Wenn ja, wird bestCost aktualisiert und die aktuelle Position des Agenten wird in bestPosition kopiert.
• Die vorherigen Kosten prevCost werden auf die aktuellen Kosten aktualisiert.
  

Die endgültige Bedeutung des Vorgangs der Revisionsmethode, der für die Aktualisierung der Zustandsinformationen der Agenten im Algorithmus zuständig ist und die folgenden Schlüsselaktionen durchführt:

1. Findet den Agenten mit den besten Kosten und aktualisiert die entsprechenden Variablen.

2. Aktualisiert die Preise aller Agenten.

3. Berechnet Wahrscheinlichkeiten auf der Grundlage der aktuellen Werte.

4. Berechnet die durchschnittlichen Kosten der Agenten.

5. Aktualisiert den Zustand der Agenten auf der Grundlage ihrer Leistung.

6. Aktualisiert die Preise und Positionen der besten Agenten.

Diese Methode ist ein wichtiger Teil des Algorithmus, da sie es den Agenten ermöglicht, sich auf der Grundlage ihres Erfolgs anzupassen und Informationen auszutauschen.

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

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

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

  //----------------------------------------------------------------------------
  for (int i = 0; i < popSize; i++) agents [i].cost = a [i].f;

  //----------------------------------------------------------------------------
  //Calculate the probabilities for bees at the current cost
  CalculateProbabilities ();

  //----------------------------------------------------------------------------
  //Calculate the average cost
  CalculateAverageCost ();

  //----------------------------------------------------------------------------
  //update bees' states (novice, experienced, search, source) 
  for (int i = 0; i < popSize; i++)
  {
    switch (agents [i].state)
    {
      case S_ABHA_Agent::stateNovice:
      {
        ChangingStateForNovice (agents [i]);
        break;
      }
      case S_ABHA_Agent::stateExperienced:
      {
        ChangingStateForExperienced (agents [i]);
        break;
      }
      case S_ABHA_Agent::stateSearch:
      {
        ChangingStateForSearch (agents [i]);
        break;
      }
      case S_ABHA_Agent::stateSource:
      {
        ChangingStateForSource (agents [i]);
        break;
      }
    }
  }
  //----------------------------------------------------------------------------
  //Update the cost for bees
  for (int i = 0; i < popSize; i++)
  {
    if (agents [i].cost > agents [i].bestCost)
    {
      agents [i].bestCost = agents [i].cost;

      ArrayCopy (agents [i].bestPosition, agents [i].position);
    }
    agents [i].prevCost = agents [i].cost;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Schlussfolgerung

Wir haben den ABHA-Bienenstock-Algorithmus betrachtet, die Prinzipien seiner Funktionsweise im Detail analysiert, den Pseudocode des Algorithmus geschrieben und auch die Struktur, Klasse und Initialisierung sowie die Methoden Moving und Revision beschrieben. Im nächsten Artikel werden wir mit dem Schreiben des Algorithmus-Codes fortfahren und alle anderen Methoden behandeln. Wie üblich werden wir Tests mit Testfunktionen durchführen und die Ergebnisse des Algorithmus in der Bewertungstabelle zusammenfassen.

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