Kamelalgorithmus (CA)
22
0
Inhalt
Einführung
In den letzten Jahrzehnten wurden zahlreiche Optimierungsalgorithmen entwickelt, die von natürlichen Phänomenen und dem Verhalten von Tieren inspiriert sind. Diese bioinspirierten Ansätze haben bei vielen Aufgaben hervorragende Ergebnisse gezeigt. In diesem Artikel untersuchen wir einen neuen Optimierungsalgorithmus, den Kamelalgorithmus (CA), der auf den Überlebens- und Bewegungsstrategien von Kamelen in extremen Wüstenbedingungen basiert. Der Algorithmus wurde im Jahr 2016 von zwei Wissenschaftlern entwickelt und vorgestellt: Mohammed Khalid Ibrahim und Ramzy Salim Ali.
Kamele haben einzigartige physiologische Eigenschaften und Verhaltensanpassungen, die es ihnen ermöglichen, sich in der rauen Wüstenumgebung mit begrenzten Ressourcen, extremen Temperaturen und wechselnden Landschaften zurechtzufinden und zu überleben. Der CA-Algorithmus modelliert Schlüsselaspekte dieses Verhaltens: den Einfluss der Temperatur, das Management von Wasser- und Nahrungsvorräten, die Ausdauer, die Wirkung von „Oasen“ (vielversprechende Suchgebiete) sowie die Gruppeninteraktion in der Karawane.
Wie üblich werden wir die Funktionsweise des ursprünglichen Algorithmus analysieren, ihn verändern und beide Versionen mit Testfunktionen testen. Die Ergebnisse werden in unsere Ranking-Tabelle des Optimierungsalgorithmus aufgenommen.
Implementierung des Algorithmus
Stellen Sie sich eine Karawane von Kamelen vor, die sich auf eine Reise durch eine riesige Wüste begibt. Ihr Ziel ist es, im endlosen Sand versteckte Oasen mit Wasser und Nahrung zu finden. Diese Reise inspirierte die Autoren zur Entwicklung des Kamelalgorithmus (CA).
Der Algorithmus simuliert, wie diese erstaunlichen Tiere unter den harten Bedingungen der Wüste überleben und Ressourcen finden. Jedes Kamel im Algorithmus ist eine potenzielle Lösung, die den Suchraum (die Wüste) erkundet, um die optimale Lösung (die reichste Oase) zu finden.
Kamelkarawanen reisen nicht ohne Grund gemeinsam – es ist eine Überlebensstrategie. Im Algorithmus tauscht eine Population von „Kamelen“ (potenziellen Lösungen) Informationen über die besten Routen aus, die sie gefunden haben, ähnlich wie echte Kamele in einer Karawane bewährten Wegen zu Wasserquellen folgen.
Schlüsselelemente:
Temperature (T) – ein zufälliger Faktor, der das Verhalten der Kamele beeinflusst. In der Wüste schwanken die Temperaturen zwischen kühlen Nächten und heißen Tagen, was sich auf die Geschwindigkeit und die Bewegungsrichtung der Kamele auswirkt. Die einzigartige Fähigkeit der Kamele, sich an extreme Temperaturen anzupassen (von kalten Nächten bis zu heißen Wüstentagen), inspirierte den Parameter „Temperatur“ im Algorithmus. Dieser Parameter führt ein Element der Zufälligkeit und Anpassungsfähigkeit ein, das dazu beiträgt, lokale Optima zu vermeiden, ähnlich wie Kamele ihre Route an veränderte Bedingungen anpassen müssen.
Supply (S) – Wasser und Nahrung, die unterwegs allmählich aufgebraucht werden. Kamele haben sich so entwickelt, dass sie unter einigen der härtesten Bedingungen der Erde überleben können. Ihre Fähigkeit, mit Ressourcen (Wasser und Nahrung) effizient hauszuhalten, spiegelt sich im Algorithmus direkt durch den Parameter „supply“ wider, der im Verlauf der „Reise“ abnimmt und die Suchstrategie beeinflusst. Je länger ein Kamel unterwegs ist, ohne eine Oase zu finden, desto weniger Energie hat es noch. Diese Eigenschaft macht den Algorithmus besonders geeignet für Probleme mit begrenzten Rechenressourcen.
Endurance (E) – die Energie des Kamels, abhängig von der Temperatur und der Dauer der Reise. Die brennende Sonne zehrt langsam an den Kräften der Karawane. Kamele sind bekannt für ihre außergewöhnliche Ausdauer und ihre Fähigkeit, lange Strecken mit minimalen Mitteln zurückzulegen. Im Algorithmus wirkt sich der Parameter „Ausdauer“ auf die Fähigkeit des Agenten aus, den Lösungsraum zu erkunden. Er nimmt mit der Zeit allmählich ab und beeinflusst das Gleichgewicht zwischen der Erkundung neuer Gebiete und der Nutzung bereits gefundener vielversprechender Lösungen.
Oasis effect – wenn ein Kamel einen vielversprechenden Ort (die beste Lösung) findet, werden seine Reserven und seine Ausdauer wiederhergestellt, sodass es seine Erkundung fortsetzen kann. Wenn der Algorithmus eine Lösung gefunden hat, werden die Parameter „supply“ und „endurance“ aufgefüllt, sodass er das Gebiet gründlicher erkunden kann, so wie ein Kamel an einer Oase eine Pause einlegt, um sich zu stärken. Dies ist eine der interessantesten Eigenschaften des Algorithmus.
Random Walk – Abweichungen vom Hauptpfad, die der Erkundung neuer Territorien dienen.
Wie in der Abbildung unten zu sehen ist, sucht eine Gruppe von fünf Kamelen nach einer reichen Oase in der Wüste. Zunächst befinden sie sich an verschiedenen Orten und bewegen sich in unterschiedliche Richtungen:
Kamel 1 ist auf dem Weg nach Norden, aber aufgrund der hohen Temperatur wird seine Geschwindigkeit verlangsamt und es muss mehr Stopps einlegen.Kamel 2 findet eine kleine Oase (lokales Optimum) mit einigen Lebensmittel- und Wasservorräten. Er informiert die anderen über seine Entdeckung, sucht aber weiter, da er vermutet, dass es irgendwo eine größere Oase gibt.
Kamel 3 wandert durch relativ flaches Gelände, seine Vorräte gehen allmählich zur Neige, aber es erkundet weiterhin neue Wege.
Kamel 4 kommt in ein Gebiet mit sehr hohen Temperaturen, was seine Ausdauer deutlich verringert. Mithilfe von Random Walk kommt er jedoch aus diesem Bereich heraus.
Kamel 5 findet mithilfe der Informationen der anderen Kamele und der günstigen Richtung des Random Walks die reichste Oase (globales Optimum).
Abbildung 1. Funktionsweise des CA-Algorithmus
Schreiben wir einen Pseudocode für den CA-Algorithmus:
// Initialisierung der Parameter
Initialisieren:
popSize = Populationsgröße (Kamelkarawane)
Tmin = Mindesttemperatur
Tmax = maximale Temperatur
omega = Lastfaktor der Versorgung
dyingRate = Sterberate der Kamele
alpha = Sichtbarkeitsparameter für den Oaseneffekt
initialSupply = Anfangsvorrat an Wasser und Nahrung (normalerweise 1,0)
initialEndurance = Anfangsausdauer (in der Regel 1,0)
totalSteps = Gesamtzahl der Schritte auf dem Weg
traveledSteps = 0 Anfangswert der zurückgelegten Schritte
// Initialisierung der Population
Erstellen einer Kamelkarawane für den Start (mehrere Lösungen):
Für jedes Kamel i von 1 bis popSize:
Generierung einer Zufallslösung innerhalb eines akzeptablen Bereichs
Ausgangswerte einstellen:
temperature [i] = Zufallswert zwischen Tmin und Tmax
supply [i] = initialSupply
endurance [i] = initialEndurance
Berechnen der Fitness der einzelnen Kamele in der Karawane
Finden der derzeit besten Lösung
// Hauptoptimierungsschleife
While (traveledSteps < totalSteps):
traveledSteps++
// Für jedes Kamel der Karawane
For i von 1 bis popSize:
// 1. Aktualisierungsfaktoren (temperature, supply, endurance)
// Gleichung (1): Tnow = (Tmax – Tmin) * Rand(0,1) + Tmin
temperature [i] = CalculateTemperature (i)
// Gleichung (2): Snow = Spast * (1 – ω * Zurückgelegte Schritte/Gesamtzahl der Reiseschritte)
supply [i] = CalculateSupply (i)
// Gleichung (4): Enow = Epast * (1 – Tnow/Tmax) * (1 – zurückgelegte Schritte /Gesamtzahl der Reiseschritte)
endurance [i] = CalculateEndurance (i)
// 2. Prüfen, ob ein Kamel „tot“ ist
If (random_number < dyingRate):
Generierung einer neuen Zufallslösung für Kamel i
Weiter zur nächsten Iteration
// 3. Aktualisieren der Position des Kamels
delta = Zufallszahl im Bereich [-1, 1] // Random Walk-Faktor
Speichern der alten Kamelkoordinaten
// Für jede Koordinate
Für jede Koordinate c:
// Berechnung der Faktoren für die Aktualisierungsgleichung
enduranceFactor = (1.0 – endurance [i] / initialEndurance)
supplyFactor = exp(1.0 – supply [i] / initialSupply)
// Aktualisierung der Position anhand der Gleichung (6)
new_position [c] = old_position [c] + delta * enduranceFactor * supplyFactor * (best_position [c] - old_position [c])
// Überprüfen, ob die Grenzen überschritten wurden, und ihre eventuelle Anpassung.
new_position [c] = Auf den gültigen Bereich beschränken
// 4. Den Oaseneffekt anwenden
If (random_number > (1.0 - alpha) && fitness_new > fitness_old):
// Eine Oase finden, Vorräte und Ausdauer wieder auffüllen
supply [i] = initialSupply
endurance [i] = initialEndurance
// Reihung der Kamele und Suche nach der besten Lösung
Aktualisieren der besten Lösung.
// Rückgabe der endgültigen besten Lösung
Jetzt können wir mit dem Schreiben des Codes beginnen, der sowohl die ursprüngliche Version der Autoren (einige Zeichenfolgen werden auskommentiert) als auch meine Änderung zur Verbesserung der Logik des Algorithmus enthalten wird. Schreiben wir die Klasse C_AO_CAm, die die Implementierung des CAm-Algorithmus darstellen und von der Basisklasse C_AO erben wird.
Die Klasse enthält Parameter, die für den Algorithmus spezifisch sind, z. B. Populationsgröße, Mindest- und Höchsttemperatur, Belastungsfaktor, Kamel-Todesrate und Sichtbarkeitsparameter. Diese Parameter können bei der Initialisierung festgelegt werden und sind bequem über das Parameter-Array konfigurierbar.
Der Klassenkonstruktor definiert die grundlegenden Eigenschaften des Algorithmus, einschließlich des Namens, der Beschreibung und des Links zur Quelle der Idee, und initialisiert das Parameter-Array. Mit der Methode SetParams können diese Parameter zur Laufzeit aktualisiert werden.
Die Klasse implementiert Methoden zum Initialisieren der Population, zum Bewegen der Kamele, zum Überarbeiten von Lösungen, zum Aktualisieren von Faktoren und zum Anwenden von oasenbezogenen Effekten – also alles, was das Verhalten von Kamelen in der Wüste simuliert und nach optimalen Lösungen sucht. Die Haupteigenschaften der Klasse sind Arrays, in denen die Temperatur jedes Kamels, seine Wasser- und Nahrungsreserven, seine Ausdauer sowie die Zähler der zurückgelegten und der gesamten Schritte gespeichert werden. Es gibt Variablen, die die Ausgangsniveaus der Reserven und der Ausdauer angeben, die normalerweise zu Beginn des Algorithmus initialisiert werden.
Im Allgemeinen implementiert diese Klasse eine modifizierte Version des Optimierungsalgorithmus, die auf dem Verhalten einer Kamelkarawane basiert, wobei „temperature“ und „supply“ Zwischenzustände der Suche modellieren und die Bewegungsdynamik und das Ausfallen einzelner Kamele eine effiziente Suche nach Lösungen unterstützen.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_CAm : public C_AO { public: //-------------------------------------------------------------------- ~C_AO_CAm () { } C_AO_CAm () { ao_name = "CA"; ao_desc = "Camel Algorithm M"; ao_link = "https://www.mql5.com/en/articles/18057"; popSize = 50; // population size (camel caravan) Tmin = 50; // minimum temperature Tmax = 100; // maximum temperature omega = 0.8; // load factor for 'supply' dyingRate = 0.01; // camels' "death" rate alpha = 0.9; // visibility parameter for the oasis effect ArrayResize (params, 6); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "Tmin"; params [1].val = Tmin; params [2].name = "Tmax"; params [2].val = Tmax; params [3].name = "omega"; params [3].val = omega; params [4].name = "dyingRate"; params [4].val = dyingRate; params [5].name = "alpha"; params [5].val = alpha; } void SetParams () { popSize = (int)params [0].val; Tmin = params [1].val; Tmax = params [2].val; omega = params [3].val; dyingRate = params [4].val; alpha = params [5].val; } bool Init (const double &rangeMinP [], // minimum values const double &rangeMaxP [], // maximum values const double &rangeStepP [], // step change const int epochsP = 0); // number of epochs void Moving (); void Revision (); //---------------------------------------------------------------------------- double Tmin; // minimum temperature double Tmax; // maximum temperature double omega; // load factor for 'supply' double dyingRate; // camels' "death" rate double alpha; // visibility parameter for the oasis effect private: //------------------------------------------------------------------- double temperature []; // current temperature for each camel double supply []; // current supply of water and food for each camel double endurance []; // current endurance for each camel double initialSupply; // initial supply (usually 1.0) double initialEndurance; // initial endurance (usually 1.0) int traveledSteps; // number of steps taken int totalSteps; // total number of steps // Auxiliary methods void InitializePopulation (); void UpdateFactors (); void UpdatePositions (); void ApplyOasisEffect (); }; //——————————————————————————————————————————————————————————————————————————————
Die Init-Methode initialisiert den CAm-Algorithmus. Während der Ausführung dieser Methode werden die erforderlichen Datenstrukturen und Parameter für die weitere Arbeit vorbereitet. Zu den wichtigsten Schritten der Methode gehört der Aufruf der Standardinitialisierung, die die Bereiche und Schritte zur Änderung der Suchvariablen festlegt. Wenn die Initialisierung fehlschlägt, schlägt auch die Methode fehl.
Als Nächstes wird Speicher für Arrays zugewiesen, in denen die Parameter jedes Kamels – Temperatur, Wasser- und Nahrungsvorrat, Ausdauer – gespeichert werden, wobei die Größe dieser Arrays der Größe der Population entspricht. Diese Arrays werden benötigt, um das Verhalten der Kamele während der Optimierung zu simulieren. Die anfänglichen Werte von supply und endurance werden festgelegt, ebenso wie die Gesamtzahl der Schritte, die der Anzahl der Epochen entspricht. Die Anzahl der zurückgelegten Schritte wird auf Null gesetzt.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_CAm::Init (const double &rangeMinP [], // minimum values const double &rangeMaxP [], // maximum values const double &rangeStepP [], // step change const int epochsP = 0) // number of epochs { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; //---------------------------------------------------------------------------- // Initialize arrays for each camel ArrayResize (temperature, popSize); ArrayResize (supply, popSize); ArrayResize (endurance, popSize); // Set initial values initialSupply = 1.0; initialEndurance = 1.0; traveledSteps = 0; totalSteps = epochsP; return true; } //——————————————————————————————————————————————————————————————————————————————
Die Methode Moving implementiert den iterativen Prozess des Algorithmus, der für die Aktualisierung der Zustände und Bewegungen der Kamele verantwortlich ist. Zunächst wird geprüft, ob die erste Iteration abgeschlossen ist; wenn nicht, wird die Anfangspopulation der Kamele initialisiert und die Initialisierung als abgeschlossen markiert.
Bei jedem weiteren Schritt wird der Zähler der abgeschlossenen Schritte erhöht, woraufhin die folgenden Aktionen nacheinander ausgeführt werden:
- Die Aktualisierung von Faktoren wie Temperatur, Versorgung und Ausdauer der einzelnen Kamele ist wichtig für die Modellierung des dynamischen Verhaltens und der Suche.
- Aktualisierung der Positionen der Kamele im Suchraum, d. h. Bewegung in eine Richtung, die die Lösung potenziell verbessert.
- Die Nutzung des Oaseneffekts, bei dem Kamele ihre Vorräte auffüllen und ihre Ausdauer wiederherstellen können, hilft dabei, lokale Minima zu vermeiden und fördert eine gründlichere Erkundung des Suchraums.
Am Ende eines jeden Schrittes wird der Wert der Fitnessfunktion für jedes Kamel gespeichert, sodass der aktuelle Zustand mit dem vorherigen verglichen werden kann und auf dieser Grundlage weitere Entscheidungen getroffen werden können.
//+----------------------------------------------------------------------------+ //| Basic optimization method | //+----------------------------------------------------------------------------+ void C_AO_CAm::Moving () { // First iteration - initialization of the initial population if (!revision) { InitializePopulation (); revision = true; return; } // Increase the steps counter traveledSteps++; // Main optimization // 1. Update factors (temperature, supply, endurance) UpdateFactors (); // 2. Update the camel positions UpdatePositions (); // 3. apply the oasis effect (replenishment of supply and endurance) ApplyOasisEffect (); // 4. Save the state of camels for (int i = 0; i < popSize; i++) a [i].fP = a [i].f; } //——————————————————————————————————————————————————————————————————————————————
Die Methode Revision ist für die Aktualisierung der besten in der aktuellen Kamelpopulation gefundenen Lösung zuständig. Die Methode iteriert über alle Kamele in der Population und vergleicht die Fitness jedes Kamels mit dem aktuell besten Wert. Wenn der Fitnesswert des aktuellen Kamels (a[i].f) besser ist als der aktuelle Bestwert (fB), dann erfolgt eine Aktualisierung:
- „fB“ wird ein neuer bester Wert zugewiesen (a[i].f).
- Die Position (Koordinaten, Parameter) des Kamels, das den besten Wert erreicht hat, wird von den Koordinaten des aktuell besten Kamels (a[i].c) in das Koordinatenfeld der besten Lösung (cB) kopiert.
Nach Abschluss der Schleife über alle Kamele in der Population enthalten fB und cB den Wert und die Koordinaten der besten Lösung, die in der aktuellen Iteration gefunden wurde.
//+----------------------------------------------------------------------------+ //| Update the best solution | //+----------------------------------------------------------------------------+ void C_AO_CAm::Revision () { // Find the best solution in the current population for (int i = 0; i < popSize; i++) { // Update the best solution if (a [i].f > fB) { fB = a [i].f; ArrayCopy (cB, a [i].c, 0, 0, WHOLE_ARRAY); } } } //——————————————————————————————————————————————————————————————————————————————
Die Methode InitializePopulation wird verwendet, um die Anfangspopulation der Kamele im Optimierungsalgorithmus zu bilden. Sie erzeugt eine gleichmäßige Verteilung der Ausgangslösungen über den gesamten realisierbaren Suchraum.
Die grundlegenden Schritte der Methode bestehen darin, die gesamte Population, d. h. alle Kamele, zu untersuchen. Für jedes Kamel werden zufällige Koordinaten innerhalb der zulässigen Bereiche für jede Variable (jede Koordinate) erzeugt. Diese Koordinaten werden nach dem Zufallsprinzip ausgewählt, um den gesamten gültigen Bereich gleichmäßig abzudecken.
Nach der Generierung der Koordinaten wird jede von ihnen auf den nächstliegenden akzeptablen Schritt gerundet, wodurch sichergestellt wird, dass die Suche die Schrittweite einhält. Damit soll sichergestellt werden, dass die Ausgangslösungen genau den zulässigen Bereichen und Schritten entsprechen. Außerdem erhält jedes Kamel Anfangswerte für Parameter wie Wasser- und Nahrungsvorräte und Ausdauer, die durch voreingestellte Standardwerte für die gesamte Population bestimmt sind.
Durch die Ausführung der Methode wird eine Startpopulation von Lösungen erzeugt, die gleichmäßig über den gesamten Suchraum verteilt ist, was einen effizienten Start der Optimierung ermöglicht.
//+----------------------------------------------------------------------------+ //| Initialize the initial population | //+----------------------------------------------------------------------------+ void C_AO_CAm::InitializePopulation () { // Initialize the initial population uniformly throughout the space for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { // Generate random coordinates within acceptable limits a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); // Round to the nearest acceptable step a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } // Initialize factors for each camel supply [i] = initialSupply; endurance [i] = initialEndurance; } } //——————————————————————————————————————————————————————————————————————————————
Die Methode UpdateFactors in der Klasse C_AO_CAm ist für die Aktualisierung der Schlüsselfaktoren zuständig, die das Verhalten der einzelnen „Kamele“ in der Population beeinflussen: Temperatur, Versorgung und Ausdauer. Diese Faktoren ändern sich bei jeder Iteration des Algorithmus dynamisch und beeinflussen die Suche nach der optimalen Lösung.
Zunächst wird die journeyRatio berechnet, d. h. das Verhältnis zwischen der Anzahl der zurückgelegten Schritte (traveledSteps) und der Gesamtzahl der Schritte (totalSteps). Dieser Wert spiegelt den Fortschritt bei der Ausführung des Algorithmus wider. Für jedes Kamel (i von 0 bis popSize -1) wird die Temperatur (temperature[i]) zufällig innerhalb des vorgegebenen Bereichs von Tmin bis Tmax festgelegt. Für jedes Kamel wird unabhängig voneinander eine neue Temperatur erzeugt, was zu einem Zufallsprozess führt.
Der Vorrat des Kamels (Vorrat [i]) nimmt in Abhängigkeit von der zurückgelegten Strecke ab. Er errechnet sich aus dem vorherigen Versorgungswert multipliziert mit dem Verhältnis (1,0 – omega * journeyRatio). Der Parameter „omega“ steuert die Erschöpfungsrate der Ressourcen. Je größer „omega“ und je größer die „journeyRatio“ (d. h. je weiter der Algorithmus fortgeschritten ist), desto schneller wird die Ressourcen erschöpft.
Die Ausdauer des Kamels (endurance [i]) nimmt sowohl mit der Temperatur als auch mit der zurückgelegten Strecke ab. Die Ausdauer wird berechnet als der vorherige Ausdauerwert multipliziert mit (1,0 – temperatureRatio) * (1,0 – journeyRatio). temperatureRatio ist das Verhältnis zwischen der aktuellen Temperatur des Kamels und der maximalen Temperatur Tmax. Je höher die Temperatur und je weiter der Algorithmus voranschreitet, desto mehr nimmt die Ausdauer ab.
Auf diese Weise ändert die Methode dynamisch die Eigenschaften der einzelnen Kamele, indem sie sowohl Zufallsvariablen (Temperatur) als auch Informationen über den Fortschritt des Algorithmus (zurückgelegte Strecke) verwendet. Diese Veränderungen wirken sich darauf aus, wie Kamele den Suchraum erkunden.
//+----------------------------------------------------------------------------+ //| Update factors (temperature, supply, endurance) | //+----------------------------------------------------------------------------+ void C_AO_CAm::UpdateFactors () { double journeyRatio = (double)traveledSteps / (double)totalSteps; for (int i = 0; i < popSize; i++) { // Temperature update - random value in the [Tmin, Tmax] range, // equation (1): Tnow = (Tmax - Tmin) * Rand(0,1) + Tmin temperature [i] = u.RNDfromCI (Tmin, Tmax); // Supply update - decreases over time, // equation (2): Snow = Spast * (1 - ω * Traveled steps / Total journey steps) supply [i] = supply [i] * (1.0 - omega * journeyRatio); // Endurance update depends on temperature and time, // equation (4): Enow = Epast * (1 - Tnow/Tmax) * (1 - Traveled steps / Total journey steps) double temperatureRatio = temperature [i] / Tmax; endurance [i] = endurance [i] * (1.0 - temperatureRatio) * (1.0 - journeyRatio); } } //——————————————————————————————————————————————————————————————————————————————
Die Methode UpdatePositions dient dazu, die Positionen der Kamele bei jedem Schritt des Optimierungsalgorithmus zu aktualisieren. Sie simuliert Bewegungen und Zufallsereignisse, die die Aktualisierung von Entscheidungen beeinflussen.
Die wichtigsten Schritte der Methode sind Iterationen über die gesamte Kamelpopulation. Für jedes Kamel werden die folgenden Schritte durchgeführt:
-
Mit einer gewissen Wahrscheinlichkeit (z. B. durch ungünstige Bedingungen wie Treibsand, Stürme oder hohe Temperaturen) wird das Kamel als tot angesehen. In diesem Fall wird seine Position im Raum innerhalb des zulässigen Bereichs zufällig neu generiert und entsprechend der Mindestschritte angepasst.
-
Wenn das Kamel nicht „stirbt“, wird seine neue Position mithilfe eines Random Walk-Modells bestimmt. Für jede Koordinatendimension wird ein zufälliger „Delta“-Faktor im Bereich [-1, 1] erzeugt, um eine zufällige Variation zu simulieren.
-
Die neue Koordinate wird als der alte Wert berechnet, zu dem ein modifizierender Term hinzugefügt wird, der die zufällige Wanderung, die aktuellen Eigenschaften des Kamels (Ausdauer und Vorrat) und die Differenz zwischen der aktuellen Koordinate und der Position der Oase berücksichtigt. In diesem Fall wird der Einfluss der „endurance“ und der Reserve „supply“ berücksichtigt.
-
Nach der Berechnung einer neuen Koordinate wird geprüft, ob sie außerhalb des zulässigen Bereichs liegt.
Als Ergebnis dieses Prozesses ändern sich die Positionen der Kamele dynamisch und simulieren ihre Bewegungen im Suchraum unter Berücksichtigung von Zufallsfaktoren und des internen Zustands (Ausdauer und Vorrat). Solche Aktualisierungen helfen dem Algorithmus, den Lösungsraum effizienter zu erkunden, lokale Minima zu vermeiden und die Suche nach der optimalen Lösung zu erleichtern.
Der kommentierte Code der ursprünglichen „Tod“- und Positionswiederherstellungsfunktion wird in der aktuellen modifizierten Version des Algorithmus nicht verwendet.
Die wichtigsten Änderungen in der geänderten Version: Die „Todesprüfung“ des Kamels wird nun für jede Koordinate einzeln durchgeführt und nicht mehr für das gesamte Kamel; statt eine neue Position völlig zufällig zu generieren, wird eine Normalverteilung (Gauß) um die beste Lösung (cB) herum verwendet; die Funktion Normalverteilung erzeugt eine neue Position auf der Grundlage einer Normalverteilung, die auf der besten Lösung zentriert ist, was eine gezieltere Erkundung vielversprechender Gebiete ermöglicht.
//+----------------------------------------------------------------------------+ //| Update camel positions | //+----------------------------------------------------------------------------+ void C_AO_CAm::UpdatePositions () { for (int i = 0; i < popSize; i++) { /* // Checking for camel "death" (quicksand, storm, etc.) if (u.RNDprobab () < dyingRate) { // Generate a new position randomly for (int c = 0; c < coords; c++) { a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } continue; } */ // Updating position------------------------------------------------------- double delta = u.RNDfromCI (-1.0, 1.0); // Random walk factor // Update each coordinate for (int c = 0; c < coords; c++) { /* // Apply the update equation from the article double enduranceFactor = (1.0 - endurance [i] / initialEndurance); double supplyFactor = MathExp (1.0 - supply [i] / initialSupply); // Update position a [i].c [c] = a [i].c [c] + delta * enduranceFactor * supplyFactor * (cB [c] - a [i].c [c]); // Check for out-of-bounds and adjust to acceptable value a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); */ // Checking for camel "death" (quicksand, storm, etc.) if (u.RNDprobab () < dyingRate) { // Generate a new position relative to the oasis coordinate using a normal distribution a [i].c [c] = u.GaussDistribution (cB [c], rangeMin [c], rangeMax [c], 8); } else { // Apply the update equation from the article double enduranceFactor = (1.0 - endurance [i] / initialEndurance); double supplyFactor = MathExp (1.0 - supply [i] / initialSupply); // Update position a [i].c [c] = a [i].c [c] + delta * enduranceFactor * supplyFactor * (cB [c] - a [i].c [c]); } // Check for out-of-bounds and adjust to acceptable value a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } } } //——————————————————————————————————————————————————————————————————————————————
Die Methode ApplyOasisEffect simuliert die Auswirkungen einer Oase auf den Zustand der Kamele während der Suche. Seine Hauptaufgabe besteht darin, festzustellen, ob das Kamel eine Oase entdeckt hat, wodurch seine Ressourcen aufgefüllt werden.
Beim Durchlaufen der gesamten Population prüft die Methode für jedes Kamel zwei Bedingungen. Die erste ist die Wahrscheinlichkeit, eine Oase zu finden, die durch eine Zufallszahl bestimmt wird und von dem Parameter „alpha“ abhängt. Je höher „alpha“ ist, desto größer ist die Chance, eine Oase zu entdecken. Die zweite Aufgabe besteht darin, zu überprüfen, ob der aktuelle Wert der Fitnessfunktion (oder die Qualität der Lösung) des Kamels besser ist als in der vorherigen Iteration. So wird sichergestellt, dass die Oase nur die Kamele betrifft, deren Leistung sich tatsächlich verbessert hat.
Wenn beide Bedingungen erfüllt sind, wird angenommen, dass das Kamel eine Oase gefunden hat. In diesem Fall werden die Versorgung und die Ausdauer auf ihre ursprünglichen Werte zurückgesetzt. So fördert die Oase die Wiederherstellung der Ressourcen des Kamels und ermöglicht es ihm, den Suchraum weiterhin aktiv und mit erhöhter Effizienz zu erkunden.
Der Grundgedanke der Methode besteht darin, die Fähigkeit der Kamele zu simulieren, Oasen zu finden, die es ihnen ermöglichen, sich zu erholen und die Suche fortzusetzen, wodurch sich ihre Chancen verbessern, das globale Optimum zu erreichen.
//+----------------------------------------------------------------------------+ //| Apply the oasis effect (refresh supply and endurance) | //+----------------------------------------------------------------------------+ void C_AO_CAm::ApplyOasisEffect () { for (int i = 0; i < popSize; i++) { // Oasis detection condition: // 1) The camel should "see" the oasis (random probability depending on 'alpha') // 2) The current solution should be better than the previous iteration if (u.RNDprobab () > (1.0 - alpha) && a [i].f > a [i].fP) { // Oasis discovered, replenish supply and endurance supply [i] = initialSupply; endurance [i] = initialEndurance; } } } //——————————————————————————————————————————————————————————————————————————————
Testergebnisse
Wie Sie sehen, erreicht die ursprüngliche Version des CA-Algorithmus einen Höchstwert von 32,56 %.
=============================
5 Hilly's; Func runs: 10000; result: 0.5872886802671936
25 Hilly's; Func runs: 10000; result: 0.3896531310299016
500 Hilly's; Func runs: 10000; result: 0.3412707468979892
=============================
5 Forest's; Func runs: 10000; result: 0.5248302942062708
25 Forest's; Func runs: 10000; result: 0.2760893244414008
500 Forest's; Func runs: 10000; result: 0.18881523788478266
=============================
5 Megacity's; Func runs: 10000; result: 0.3507692307692308
25 Megacity's; Func runs: 10000; result: 0.16676923076923078
500 Megacity's; Func runs: 10000; result: 0.10464615384615475
=============================
All score: 2.93013 (32.56%)
Der modifizierte Algorithmus zeigt bessere Ergebnisse:
CAm|Camel Algorithm|50.0|50.0|100.0|0.8|0.01|0.9|
=============================
5 Hilly's; Func runs: 10000; result: 0.786842172387197
25 Hilly's; Func runs: 10000; result: 0.560421361070792
500 Hilly's; Func runs: 10000; result: 0.3513297097198401
=============================
5 Forest's; Func runs: 10000; result: 0.8277193604225209
25 Forest's; Func runs: 10000; result: 0.5604138230149972
500 Forest's; Func runs: 10000; result: 0.24335977579892912
=============================
5 Megacity's; Func runs: 10000; result: 0.6484615384615386
25 Megacity's; Func runs: 10000; result: 0.33092307692307693
500 Megacity's; Func runs: 10000; result: 0.13417692307692433
=============================
All score: 4.44365 (49.37%)
Zum besseren Verständnis der Unterschiede zwischen den beiden Algorithmen wird die Funktionsweise des Algorithmus für die CA- und CAm-Versionen veranschaulicht. Beide Versionen weisen die für die Logik des Algorithmus charakteristische „Verklumpung“ in der Nähe von potenziell guten Lösungen auf.
CA mit der Testfunktion Hilly
CAm mit der Testfunktion Hilly
CA mit der Testfunktion Forest
CAm mit der Testfunktion Forest
CA mit der Testfunktion Megacity
CAm mit der Testfunktion Megacity
Die modifizierte Version des Algorithmus liegt auf Platz 35 in der Rangliste der Populationsoptimierungsalgorithmen. Die Originalversion wird nur zu Informationszwecken gezeigt und nicht im Ranking geführt.
| # | AO | Beschreibung | Hilly | Hilly Final | Forest | Forest Final | Megacity (discrete) | Megacity Final | Final Result | % of MAX | ||||||
| 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | ||||||||
| 1 | ANS | Suche über die gesamte Nachbarschaft | 0.94948 | 0.84776 | 0.43857 | 2.23581 | 1.00000 | 0.92334 | 0.39988 | 2.32323 | 0.70923 | 0.63477 | 0.23091 | 1.57491 | 6.134 | 68.15 |
| 2 | CLA | Code-Lock-Algorithmus (joo) | 0.95345 | 0.87107 | 0.37590 | 2.20042 | 0.98942 | 0.91709 | 0.31642 | 2.22294 | 0.79692 | 0.69385 | 0.19303 | 1.68380 | 6.107 | 67.86 |
| 3 | AMOm | Optimierung der Tiermigration M | 0.90358 | 0.84317 | 0.46284 | 2.20959 | 0.99001 | 0.92436 | 0.46598 | 2.38034 | 0.56769 | 0.59132 | 0.23773 | 1.39675 | 5.987 | 66.52 |
| 4 | (P+O)ES | (P+O) Entwicklungsstrategien | 0.92256 | 0.88101 | 0.40021 | 2.20379 | 0.97750 | 0.87490 | 0.31945 | 2.17185 | 0.67385 | 0.62985 | 0.18634 | 1.49003 | 5.866 | 65.17 |
| 5 | CTA | Kometenschweif-Algorithmus (joo) | 0.95346 | 0.86319 | 0.27770 | 2.09435 | 0.99794 | 0.85740 | 0.33949 | 2.19484 | 0.88769 | 0.56431 | 0.10512 | 1.55712 | 5.846 | 64.96 |
| 6 | TETA | Zeit-Evolutions-Reise-Algorithmus (Joo) | 0.91362 | 0.82349 | 0.31990 | 2.05701 | 0.97096 | 0.89532 | 0.29324 | 2.15952 | 0.73462 | 0.68569 | 0.16021 | 1.58052 | 5.797 | 64.41 |
| 7 | SDSm | stochastische Diffusionssuche M | 0.93066 | 0.85445 | 0.39476 | 2.17988 | 0.99983 | 0.89244 | 0.19619 | 2.08846 | 0.72333 | 0.61100 | 0.10670 | 1.44103 | 5.709 | 63.44 |
| 8 | BOAm | Billard-Optimierungsalgorithmus M | 0.95757 | 0.82599 | 0.25235 | 2.03590 | 1.00000 | 0.90036 | 0.30502 | 2.20538 | 0.73538 | 0.52523 | 0.09563 | 1.35625 | 5.598 | 62.19 |
| 9 | AAm | Algorithmus für das Bogenschießen M | 0.91744 | 0.70876 | 0.42160 | 2.04780 | 0.92527 | 0.75802 | 0.35328 | 2.03657 | 0.67385 | 0.55200 | 0.23738 | 1.46323 | 5.548 | 61.64 |
| 10 | ESG | Entwicklung sozialer Gruppen (joo) | 0.99906 | 0.79654 | 0.35056 | 2.14616 | 1.00000 | 0.82863 | 0.13102 | 1.95965 | 0.82333 | 0.55300 | 0.04725 | 1.42358 | 5.529 | 61.44 |
| 11 | SIA | Simuliertes isotropes Glühen (Joo) | 0.95784 | 0.84264 | 0.41465 | 2.21513 | 0.98239 | 0.79586 | 0.20507 | 1.98332 | 0.68667 | 0.49300 | 0.09053 | 1.27020 | 5.469 | 60.76 |
| 12 | ACS | künstliche, kooperative Suche | 0.75547 | 0.74744 | 0.30407 | 1.80698 | 1.00000 | 0.88861 | 0.22413 | 2.11274 | 0.69077 | 0.48185 | 0.13322 | 1.30583 | 5.226 | 58.06 |
| 13 | DA | dialektischer Algorithmus | 0.86183 | 0.70033 | 0.33724 | 1.89940 | 0.98163 | 0.72772 | 0.28718 | 1.99653 | 0.70308 | 0.45292 | 0.16367 | 1.31967 | 5.216 | 57.95 |
| 14 | BHAm | Algorithmus für schwarze Löcher M | 0.75236 | 0.76675 | 0.34583 | 1.86493 | 0.93593 | 0.80152 | 0.27177 | 2.00923 | 0.65077 | 0.51646 | 0.15472 | 1.32195 | 5.196 | 57.73 |
| 15 | ASO | Anarchische Gesellschaftsoptimierung | 0.84872 | 0.74646 | 0.31465 | 1.90983 | 0.96148 | 0.79150 | 0.23803 | 1.99101 | 0.57077 | 0.54062 | 0.16614 | 1.27752 | 5.178 | 57.54 |
| 16 | RFO | Optimierung des Royal Flush (joo) | 0.83361 | 0.73742 | 0.34629 | 1.91733 | 0.89424 | 0.73824 | 0.24098 | 1.87346 | 0.63154 | 0.50292 | 0.16421 | 1.29867 | 5.089 | 56.55 |
| 17 | AOSm | Suche nach atomaren Orbitalen M | 0.80232 | 0.70449 | 0.31021 | 1.81702 | 0.85660 | 0.69451 | 0.21996 | 1.77107 | 0.74615 | 0.52862 | 0.14358 | 1.41835 | 5.006 | 55.63 |
| 18 | TSEA | Schildkrötenpanzer-Evolutionsalgorithmus (joo) | 0.96798 | 0.64480 | 0.29672 | 1.90949 | 0.99449 | 0.61981 | 0.22708 | 1.84139 | 0.69077 | 0.42646 | 0.13598 | 1.25322 | 5.004 | 55.60 |
| 19 | DE | differentielle Evolution | 0.95044 | 0.61674 | 0.30308 | 1.87026 | 0.95317 | 0.78896 | 0.16652 | 1.90865 | 0.78667 | 0.36033 | 0.02953 | 1.17653 | 4.955 | 55.06 |
| 20 | SRA | Algorithmus für erfolgreiche Gastronomen (joo) | 0.96883 | 0.63455 | 0.29217 | 1.89555 | 0.94637 | 0.55506 | 0.19124 | 1.69267 | 0.74923 | 0.44031 | 0.12526 | 1.31480 | 4.903 | 54.48 |
| 21 | CRO | Optimierung chemischer Reaktionen | 0.94629 | 0.66112 | 0.29853 | 1.90593 | 0.87906 | 0.58422 | 0.21146 | 1.67473 | 0.75846 | 0.42646 | 0.12686 | 1.31178 | 4.892 | 54.36 |
| 22 | BIO | Optimierung der Blutvererbung (joo) | 0.81568 | 0.65336 | 0.30877 | 1.77781 | 0.89937 | 0.65319 | 0.21760 | 1.77016 | 0.67846 | 0.47631 | 0.13902 | 1.29378 | 4.842 | 53.80 |
| 23 | BSA | Vogelschwarm-Algorithmus | 0.89306 | 0.64900 | 0.26250 | 1.80455 | 0.92420 | 0.71121 | 0.24939 | 1.88479 | 0.69385 | 0.32615 | 0.10012 | 1.12012 | 4.809 | 53.44 |
| 24 | HS | Harmoniesuche | 0.86509 | 0.68782 | 0.32527 | 1.87818 | 0.99999 | 0.68002 | 0.09590 | 1.77592 | 0.62000 | 0.42267 | 0.05458 | 1.09725 | 4.751 | 52.79 |
| 25 | SSG | Setzen, Säen und Wachsen | 0.77839 | 0.64925 | 0.39543 | 1.82308 | 0.85973 | 0.62467 | 0.17429 | 1.65869 | 0.64667 | 0.44133 | 0.10598 | 1.19398 | 4.676 | 51.95 |
| 26 | BCOm | Optimierung mit der bakteriellen Chemotaxis M | 0.75953 | 0.62268 | 0.31483 | 1.69704 | 0.89378 | 0.61339 | 0.22542 | 1.73259 | 0.65385 | 0.42092 | 0.14435 | 1.21912 | 4.649 | 51.65 |
| 27 | ABO | Optimierung des afrikanischen Büffels | 0.83337 | 0.62247 | 0.29964 | 1.75548 | 0.92170 | 0.58618 | 0.19723 | 1.70511 | 0.61000 | 0.43154 | 0.13225 | 1.17378 | 4.634 | 51.49 |
| 28 | (PO)ES | (PO) Entwicklungsstrategien | 0.79025 | 0.62647 | 0.42935 | 1.84606 | 0.87616 | 0.60943 | 0.19591 | 1.68151 | 0.59000 | 0.37933 | 0.11322 | 1.08255 | 4.610 | 51.22 |
| 29 | FBA | Fraktal-basierter Algorithmus | 0.79000 | 0.65134 | 0.28965 | 1.73099 | 0.87158 | 0.56823 | 0.18877 | 1.62858 | 0.61077 | 0.46062 | 0.12398 | 1.19537 | 4.555 | 50.61 |
| 30 | TSm | Tabu-Suche M | 0.87795 | 0.61431 | 0.29104 | 1.78330 | 0.92885 | 0.51844 | 0.19054 | 1.63783 | 0.61077 | 0.38215 | 0.12157 | 1.11449 | 4.536 | 50.40 |
| 31 | BSO | Brainstorming-Optimierung | 0.93736 | 0.57616 | 0.29688 | 1.81041 | 0.93131 | 0.55866 | 0.23537 | 1.72534 | 0.55231 | 0.29077 | 0.11914 | 0.96222 | 4.498 | 49.98 |
| 32 | WOAm | Wal-Optimierungsalgorithmus M | 0.84521 | 0.56298 | 0.26263 | 1.67081 | 0.93100 | 0.52278 | 0.16365 | 1.61743 | 0.66308 | 0.41138 | 0.11357 | 1.18803 | 4.476 | 49.74 |
| 33 | AEFA | Algorithmus für künstliche elektrische Felder | 0.87700 | 0.61753 | 0.25235 | 1.74688 | 0.92729 | 0.72698 | 0.18064 | 1.83490 | 0.66615 | 0.11631 | 0.09508 | 0.87754 | 4.459 | 49.55 |
| 34 | AEO | Algorithmus zur Optimierung auf der Grundlage künstlicher Ökosysteme | 0.91380 | 0.46713 | 0.26470 | 1.64563 | 0.90223 | 0.43705 | 0.21400 | 1.55327 | 0.66154 | 0.30800 | 0.28563 | 1.25517 | 4.454 | 49.49 |
| 35 | CAm | Kamelalgorithmus M | 0.78684 | 0.56042 | 0.35133 | 1.69859 | 0.82772 | 0.56041 | 0.24336 | 1.63149 | 0.64846 | 0.33092 | 0.13418 | 1.11356 | 4.444 | 49.37 |
| 36 | ACOm | Ameisen-Kolonie-Optimierung M | 0.88190 | 0.66127 | 0.30377 | 1.84693 | 0.85873 | 0.58680 | 0.15051 | 1.59604 | 0.59667 | 0.37333 | 0.02472 | 0.99472 | 4.438 | 49.31 |
| 37 | BFO-GA | Optimierung der bakteriellen Futtersuche — ga | 0.89150 | 0.55111 | 0.31529 | 1.75790 | 0.96982 | 0.39612 | 0.06305 | 1.42899 | 0.72667 | 0.27500 | 0.03525 | 1.03692 | 4.224 | 46.93 |
| 38 | SOA | einfacher Optimierungsalgorithmus | 0.91520 | 0.46976 | 0.27089 | 1.65585 | 0.89675 | 0.37401 | 0.16984 | 1.44060 | 0.69538 | 0.28031 | 0.10852 | 1.08422 | 4.181 | 46.45 |
| 39 | ABHA | Algorithmus für künstliche Bienenstöcke | 0.84131 | 0.54227 | 0.26304 | 1.64663 | 0.87858 | 0.47779 | 0.17181 | 1.52818 | 0.50923 | 0.33877 | 0.10397 | 0.95197 | 4.127 | 45.85 |
| 40 | ACMO | Optimierung atmosphärischer Wolkenmodelle | 0.90321 | 0.48546 | 0.30403 | 1.69270 | 0.80268 | 0.37857 | 0.19178 | 1.37303 | 0.62308 | 0.24400 | 0.10795 | 0.97503 | 4.041 | 44.90 |
| 41 | ADAMm | adaptive Momentabschätzung M | 0.88635 | 0.44766 | 0.26613 | 1.60014 | 0.84497 | 0.38493 | 0.16889 | 1.39880 | 0.66154 | 0.27046 | 0.10594 | 1.03794 | 4.037 | 44.85 |
| 42 | CGO | Chaos Game Optimization | 0.57256 | 0.37158 | 0.32018 | 1.26432 | 0.61176 | 0.61931 | 0.62161 | 1.85267 | 0.37538 | 0.21923 | 0.19028 | 0.78490 | 3.902 | 43.35 |
| 43 | ATAm | Algorithmus für künstliche Stämme M | 0.71771 | 0.55304 | 0.25235 | 1.52310 | 0.82491 | 0.55904 | 0.20473 | 1.58867 | 0.44000 | 0.18615 | 0.09411 | 0.72026 | 3.832 | 42.58 |
| 44 | CROm | Korallenriff-Optimierung M | 0.78512 | 0.46032 | 0.25958 | 1.50502 | 0.86688 | 0.35297 | 0.16267 | 1.38252 | 0.63231 | 0.26738 | 0.10734 | 1.00703 | 3.895 | 43.27 |
| 45 | CFO | Schwerkraftoptimierung | 0.60961 | 0.54958 | 0.27831 | 1.43750 | 0.63418 | 0.46833 | 0.22541 | 1.32792 | 0.57231 | 0.23477 | 0.09586 | 0.90294 | 3.668 | 40.76 |
| CA | Kamel-Algorithmus | 0.58729 | 0.38965 | 0.34127 | 1.31821 | 0.52483 | 0.27609 | 0.18882 | 0.98974 | 0.35077 | 0.16677 | 0.10465 | 0.62219 | 2.930 | 32.56 | |
| RW | Neuroboids Optimierungsalgorithmus 2(joo) | 0.48754 | 0.32159 | 0.25781 | 1.06694 | 0.37554 | 0.21944 | 0.15877 | 0.75375 | 0.27969 | 0.14917 | 0.09847 | 0.52734 | 2.348 | 26.09 | |
Zusammenfassung
Die modifizierte Version des CAm-Kamelalgorithmus ist dank einer Reihe von wichtigen Verbesserungen deutlich leistungsfähiger als das Original.
Zunächst einmal wurde der „Todesmechanismus“ des Kamels grundlegend geändert: Statt völlig zufällig neue Lösungen zu generieren, wird eine Normalverteilung um die beste gefundene Lösung herum verwendet, was eine gezielte und intensive Suche in den vielversprechendsten Bereichen gewährleistet.
Die genaue Verfolgung von Lösungsverbesserungen durch Speicherung früherer Fitnessfunktionswerte für jedes Kamel gewährleistet eine genauere Anwendung des Oaseneffekts. Die Erhöhung der Flexibilität des Algorithmus durch Hinzufügen von „Tmin“ zu den einstellbaren Parametern und die Verwendung eines externen Parameters zur Bestimmung der Gesamtzahl der Schritte macht CAm anpassungsfähiger an verschiedene Arten von Optimierungsproblemen.
Zusammengenommen verbessern diese Verbesserungen die modifizierte Version erheblich in Bezug auf Konvergenzgeschwindigkeit, Lösungsgenauigkeit und Stabilität.
Abbildung 2. Farbskala der Algorithmen nach den entsprechenden Tests
Abbildung 3. Histogramm der Algorithmus-Testergebnisse (Skala von 0 bis 100, je höher, desto besser, wobei 100 das maximal mögliche theoretische Ergebnis ist; im Archiv befindet sich ein Skript zur Berechnung der Bewertungstabelle)
Die Vor- und Nachteile von CAm:
Vorteile:
- Schnell.
- Einfache Implementierung.
- Gute Ergebnisse bei Funktionen großer und mittlerer Dimensionen (insbesondere bei „glatten“ Problemen).
Nachteile:
- Eine große Anzahl von externen Parametern.
- Streuung der Ergebnisse bei niedrigdimensionalen Funktionen.
Der Artikel wird von einem Archiv mit den aktuellen Versionen der Algorithmuscodes begleitet. Der Autor des Artikels übernimmt keine Verantwortung für die absolute Richtigkeit der Beschreibung der kanonischen Algorithmen. An vielen von ihnen wurden Änderungen vorgenommen, um die Suchleistung zu verbessern. Die in den Artikeln dargelegten Schlussfolgerungen und Urteile beruhen auf den Ergebnissen der Experimente.
Programme, die in diesem Artikel verwendet werden
| # | Name | Typ | Beschreibung |
|---|---|---|---|
| 1 | #C_AO.mqh | Include | Übergeordnete Klasse von Populationsoptimierungsalgorithmen |
| 2 | #C_AO_enum.mqh | Include | Enumeration der Algorithmen zur Populationsoptimierung |
| 3 | TestFunctions.mqh | Include | Bibliothek mit Testfunktionen |
| 4 | TestStandFunctions.mqh | Include | Bibliothek mit Funktionen für die Testumgebung |
| 5 | Utilities.mqh | Include | Bibliothek mit Hilfsfunktionen |
| 6 | CalculationTestResults.mqh | Include | Skript zur Berechnung der Ergebnisse in der Vergleichstabelle |
| 7 | Testing AOs.mq5 | Skript | Die einheitliche Testumgebung für alle Algorithmen zur Populationsoptimierung |
| 8 | Simple use of population optimization algorithms.mq5 | Skript | Ein einfaches Beispiel für die Verwendung von Algorithmen zur Populationsoptimierung ohne Visualisierung |
| 9 | Test_AO_CAm.mq5 | Skript | CAm-Testumgebung |
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/18057
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.
MetaTrader 5 und der MQL5-Wirtschaftskalender: Wie sich News in ein reproduzierbares Handelssystem umwandeln lassen
Einsatz spieltheoretischer Ansätze in Handelsalgorithmen
Arbitragehandel im Forex-Markt: Ein Matrix-Handelssystem mit Rückkehr zum fairen Wert mit Risikokontrolle
Python + MetaTrader 5: Schnelles Forschungs-Framework für Daten, Merkmale und Prototypen
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.