Chaos-Optimierungsalgorithmus (COA): Fortsetzung
30
2
Inhalt
Einführung
Im vorangegangenen Artikel haben wir die chaotische Optimierungsmethode vorgestellt und einige der in diesem Algorithmus enthaltenen Methoden analysiert. In diesem Artikel werden wir die Analyse der übrigen Methoden abschließen und direkt zum Testen des Algorithmus mit Testfunktionen übergehen.
Bei dieser Implementierung verwendet die chaotische Optimierungsmethode deterministisches Chaos, um den Lösungsraum zu erkunden. Das Schlüsselprinzip ist die Verwendung von drei verschiedenen chaotischen Abbildungen (logistische, Sinus- und Tent-Abbildung), um Sequenzen zu erzeugen, die Pseudo-Zufälligkeit und Ergodizität aufweisen. Der Algorithmus läuft in drei Phasen ab: eine anfängliche chaotische Suche, eine Verfeinerung der Lösung mithilfe der gewichteten Gradientenmethode und eine abschließende lokale Suche mit adaptiver Eingrenzung des Bereichs.
Die Verwendung von Geschwindigkeitsvektoren mit Trägheit und Mechanismen zur Erkennung von Stagnation hilft dem Algorithmus, lokale Extremwerte zu vermeiden. Eine dynamische Anpassung der Parameter und verschiedene Arten von Mutationen sorgen für ein Gleichgewicht zwischen globaler Erkundung und lokaler Verfeinerung der gefundenen Lösungen. Schauen wir uns nun die übrigen Methoden an.
Implementierung des Algorithmus
Die Methode ApplyMutation dient dazu, bei einem Agenten Mutationen vorzunehmen. Ihre Hauptaufgabe besteht darin, die Parameter eines bestimmten Agenten zufällig zu ändern.
Zunächst soll die Gültigkeit des Agentenindex sichergestellt werden. Liegt der Index außerhalb des Bereichs, bricht die Methode ab. Als Nächstes werden Informationen über die Größe verschiedener mit dem Agenten verbundener Felder gesammelt, z. B. die Größe seiner Parameter und seine Geschwindigkeit. Dadurch wird verhindert, dass die Methode die Grenzen dieser Arrays überschreitet.
Die Methode berechnet die maximale Anzahl der Koordinaten, die geändert werden können, auf der Grundlage der Größe der verfügbaren Arrays, um die Sicherheit der Operationen zu gewährleisten. Es wird eine Zufallszahl gewählt, um zu bestimmen, wie viele Koordinaten mutiert werden sollen. Dieser Wert liegt zwischen 1 und 30 % der maximalen Anzahl der verfügbaren Koordinaten. Es wird ein Array von Indizes gebildet, die die Koordinaten darstellen, die geändert werden können. Dieses Feld wird gemischt, um eine zufällige Auswahl bei der Anwendung von Mutationen zu gewährleisten.
In der Schleife werden die Koordinaten für die Mutation aus dem gemischten Array ausgewählt. Für jede ausgewählte Koordinate wird ein Mutationstyp auf der Grundlage eines Zufallswertes bestimmt. Zu den möglichen Arten gehören die vollständige Zufallsmutation (bei der ein neuer Wert innerhalb eines bestimmten Bereichs zufällig ausgewählt wird), die Mutation in Bezug auf die global beste Lösung und die Mutation mittels chaotischer Abbildungen.
Nach dem Ändern der Werte für die einzelnen Koordinaten wird die Geschwindigkeit des Agenten zurückgesetzt, sodass der neue Wert nicht von früheren Geschwindigkeiten beeinflusst wird. Schließlich wird der neue Wert für die entsprechende Agentenkoordinate unter Berücksichtigung der Spannen und Stufen festgelegt, wodurch sichergestellt wird, dass die Werte innerhalb des zulässigen Bereichs bleiben.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_COA_chaos::ApplyMutation (int agentIdx) { // Determine the number of coordinates for mutation (from 1 to 30% of coordinates) int mutationCount = 1 + (int)(u.RNDprobab () * coords * 0.3); mutationCount = MathMin (mutationCount, coords); // Create an array of indices for mutation without repetitions int mutationIndices []; ArrayResize (mutationIndices, coords); // Fill the array with indices for (int i = 0; i < coords; i++) { mutationIndices [i] = i; } // Shuffle the indices for (int i = coords - 1; i > 0; i--) { int j = (int)(u.RNDprobab () * (i + 1)); if (j <= i) // Additional security check { int temp = mutationIndices [i]; mutationIndices [i] = mutationIndices [j]; mutationIndices [j] = temp; } } // Apply mutations to the selected coordinates for (int m = 0; m < mutationCount; m++) { int c = mutationIndices [m]; // Different types of mutations for variety double r = u.RNDprobab (); double x; if (r < 0.3) { // Complete random mutation x = rangeMin [c] + u.RNDprobab () * (rangeMax [c] - rangeMin [c]); } else if (r < 0.6) { // Mutation relative to global best double offset = (u.RNDprobab () - 0.5) * (rangeMax [c] - rangeMin [c]) * 0.2; x = cB [c] + offset; } else { // Mutation using chaotic map agent [agentIdx].gamma [c] = SelectChaosMap (agent [agentIdx].gamma [c], (epochNow + c) % 3); x = rangeMin [c] + agent [agentIdx].gamma [c] * (rangeMax [c] - rangeMin [c]); } // Reset velocity agent [agentIdx].velocity [c] = 0.0; // Apply the new value with range check a [agentIdx].c [c] = u.SeInDiSp (x, rangeMin [c], rangeMax [c], rangeStep [c]); } } //——————————————————————————————————————————————————————————————————————————————
Die UpdateSigma-Methode der Klasse ist für die dynamische Anpassung des bei der Optimierung verwendeten Strafparameters zuständig. Sie regelt den Strafwert in Abhängigkeit von der Anzahl der zulässigen Lösungen in der Agentenpopulation.
Wenn die Methode zum ersten Mal aufgerufen wird (Epoche ist 1), wird der aktuelle Strafwert (currentSigma) auf die Hälfte des Basiswertes (sigma) gesetzt. Die Methode durchläuft die gesamte Agentenpopulation und berechnet die Anzahl der zulässigen Lösungen. Zu diesem Zweck wird eine Hilfsfunktion verwendet, um festzustellen, ob der Agent zulässig ist. Hier wird eine Iteration über alle Agenten durchgeführt, sodass wir feststellen können, wie viele von ihnen die vorgegebenen Kriterien erfüllen.
Anschließend berechnet die Methode den Anteil der zulässigen Lösungen an der Gesamtpopulation, indem sie die Anzahl der zulässigen Lösungen durch die Gesamtzahl der Agenten teilt. Dieses Verhältnis hilft uns zu verstehen, wie gut unsere derzeitige Strategie funktioniert. Auf der Grundlage des berechneten Verhältnisses der zulässigen Lösungen trifft die Methode Entscheidungen über die Anpassung der Strafe: Liegt der Anteil zulässiger Lösungen unter 30 %, deutet dies darauf hin, dass der Algorithmus zu restriktiv vorgeht; daher wird die Strafe erhöht, um die Suchdynamik zu verändern und eine größere Diversität im Verhalten der Agenten zu fördern. Wenn der Anteil 70 % übersteigt, deutet dies darauf hin, dass zu viele Agenten zulässige Lösungen finden, und die Strafe wird verringert, um eine vorzeitige Konvergenz zu vermeiden.
Letztlich sorgt die Methode dafür, dass der Wert der aktuellen Strafe innerhalb der zulässigen Grenzen bleibt. Wird er zu klein (weniger als 10 % des Basiswerts), erhöht sich die Strafe auf diesen Wert. Übersteigt die Strafe 500 % des Basiswerts, so wird sie auf diesen Wert gedeckelt.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_COA_chaos::UpdateSigma () { // Dynamic adaptation of the penalty parameter // Start with a small value and increase it if necessary if (epochNow == 1) { currentSigma = sigma * 0.5; return; } // Calculate the number of feasible solutions int feasibleCount = 0; for (int i = 0; i < popSize; i++) { if (IsFeasible (i)) { feasibleCount++; } } double feasibleRatio = (double)feasibleCount / MathMax (1, popSize); // Adapt the penalty parameter depending on the proportion of feasible solutions if (feasibleRatio < 0.3) { // Too few feasible solutions - increase the penalty currentSigma *= 1.2; } else if (feasibleRatio > 0.7) { // Too many feasible solutions - reduce the penalty currentSigma *= 0.9; } // Limit the sigma value if (currentSigma < sigma * 0.1) currentSigma = sigma * 0.1; else if (currentSigma > sigma * 5.0) currentSigma = sigma * 5.0; } //——————————————————————————————————————————————————————————————————————————————
Die IsFeasible-Methode bestimmt, ob eine bestimmte Lösung, die durch einen Agenten mit einem gegebenen Index agentIdx repräsentiert wird, unter Berücksichtigung der gegebenen Nebenbedingungen zulässig ist.
Zunächst prüft die Methode, ob der angegebene Agentenindex (agentIdx) innerhalb des zulässigen Bereichs liegt, d. h. größer oder gleich 0 und kleiner als die Populationsgröße (popSize). Wenn der Index unzulässig ist, gibt die Methode „false“ zurück und signalisiert damit, dass die Lösung unzulässig ist. Wenn der Agentenindex zulässig ist, beginnt die Methode mit der Überprüfung der Nebenbedingungen für die gegebene Lösung. Es durchläuft alle Koordinaten der Lösung und berechnet den Wert der Verletzung der Nebenbedingung für jede Koordinate mit der Funktion CalculateConstraintValue.
Die Funktion CalculateConstraintValue gibt einen Wert zurück, der den Grad der Verletzung der Nebenbedingung für eine bestimmte Lösungskoordinate angibt. Wenn nach der Überprüfung aller Koordinaten keine Nebenbedingung verletzt wird, d. h. alle Werte der Verletzung kleiner oder gleich „eps“ sind, dann wird die Lösung als zulässig angesehen und die Methode gibt „true“ zurück.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_COA_chaos::IsFeasible (int agentIdx) { // Check if the solution is within the feasible region for (int c = 0; c < coords; c++) { double violation = CalculateConstraintValue (agentIdx, c); if (violation > eps) { return false; } } return true; } //——————————————————————————————————————————————————————————————————————————————
Die Methode UpdateBestHistory speichert den aktuell besten Wert in der Suchhistorie. Sie nimmt den neuen besten Wert und prüft zunächst, ob er korrekt oder zulässig ist. Wenn der Wert korrekt ist, wird er in dem Array, das die Historie der besten Ergebnisse speichert, an der aktuellen indizierten Position gespeichert. Danach wird der Index für die nächste Speicherung mit einer zyklischen Aktualisierung aktualisiert, wobei die Rest-Operation der Division durch die Größe des History-Arrays verwendet wird, wodurch sichergestellt wird, dass die History immer mit den letzten 10 Werten gefüllt wird, ohne dass die Array-Grenzen überschritten werden.
Die Methode ermöglicht es, den Suchfortschritt zu verfolgen und die Historie der besten Lösungen für die Analyse zu nutzen.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_COA_chaos::UpdateBestHistory (double newBest) { // Protection against invalid values if (!MathIsValidNumber (newBest)) return; // Update the history of the best values globalBestHistory [historyIndex] = newBest; historyIndex = (historyIndex + 1) % 10; } //——————————————————————————————————————————————————————————————————————————————
Die Methode IsConverged wird verwendet, um festzustellen, ob der Algorithmus Konvergenz erreicht hat. Sie analysiert die Historie der besten globalen Lösungen, um zu beurteilen, wie stark sich diese Lösungen im Laufe der Zeit verbessern. Wenn die Verbesserungen unbedeutend werden, gilt der Algorithmus als konvergiert.
Die Methode initialisiert Variablen, um die Anzahl der erlaubten (zulässigen) Werte, die Summe der Werte, die Minimal- und Maximalwerte aus der Historie der besten globalen Lösungen (globalBestHistory) zu zählen. Die Variablen minVal und maxVal werden mit den größtmöglichen bzw. kleinstmöglichen Double-Werten initialisiert, um das Minimum und Maximum in Zukunft korrekt zu bestimmen.
Die Methode iteriert über das Array globalBestHistory und führt für jeden Wert in der Historie Gültigkeits-, Datenvollständigkeits- und Diversitätsprüfungen durch, berechnet den Mittelwert und die relative Differenz und prüft auf Konvergenz. Im Allgemeinen bietet die IsConverged-Methode eine Möglichkeit, die Konvergenz eines Optimierungsalgorithmus zu bestimmen, indem die Historie der besten Lösungen analysiert und bewertet wird, wie signifikant die Verbesserungen im Laufe der Zeit sind.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_COA_chaos::IsConverged () { // Check if there is enough data in the history int validValues = 0; double sum = 0.0; double minVal = DBL_MAX; double maxVal = -DBL_MAX; // Find min, max, and sum of values in history for (int i = 0; i < 10; i++) { if (globalBestHistory [i] == -DBL_MAX || !MathIsValidNumber (globalBestHistory [i])) continue; minVal = MathMin (minVal, globalBestHistory [i]); maxVal = MathMax (maxVal, globalBestHistory [i]); sum += globalBestHistory [i]; validValues++; } // If there is not enough data or all values are the same if (validValues < 5 || minVal == maxVal) return false; // Calculate the average value double average = sum / validValues; // Check the case when the mean is close to zero if (MathAbs (average) < eps) return MathAbs (maxVal - minVal) < eps * 10.0; // Relative difference for convergence testing double relDiff = MathAbs (maxVal - minVal) / MathAbs (average); return relDiff < 0.001; // Convergence threshold - 0.1% } //——————————————————————————————————————————————————————————————————————————————
Die Methode ResetStagnatingAgents wurde entwickelt, um Agenten während der Optimierung zu verwalten, insbesondere um Fälle zu behandeln, in denen Agenten keine Verbesserung ihrer Ergebnisse mehr zeigen. Sie überwacht den Zustand der Stagnation der Agenten und wendet gegebenenfalls Mutation auf diejenigen von ihnen an, die in lokalen Extremen feststecken.
Für jeden Agenten wird geprüft, ob sich sein aktueller Fitnessfunktionswert (a[i].f) im Vergleich zu seinem vorherigen Wert (a[i].fB) verbessert hat. Hat sich der aktuelle Wert nicht verbessert oder verschlechtert, wird der stagnationCounter des Agenten erhöht, was signalisiert, dass sich der Agent in einem Zustand der Stagnation befindet. Wenn sich der Wert verbessert hat, wird der Stagnationszähler zurückgesetzt.
Wenn der Agent für mehr als 5 Iterationen stagniert, berechnet die Methode die Reset-Wahrscheinlichkeit (resetProb). Diese Wahrscheinlichkeit ist proportional zum aktuellen Wert des Stagnationszählers, d. h. je länger der Agent stagniert, desto höher ist die Wahrscheinlichkeit, dass er zurückgesetzt wird. Die Gleichung zur Berechnung der Wahrscheinlichkeit berücksichtigt einen festen Wert (0,2) und den relativen Wert des Stagnationszählers. Ist der zufällig erzeugte Wert kleiner als die berechnete resetProb-Wahrscheinlichkeit, wird mit der Funktion ApplyMutation eine Mutation auf den Agenten angewendet. Nach Anwendung einer Mutation wird der Stagnationszähler des Agenten zurückgesetzt und der resetCount-Zähler erhöht.
Die Methode endet nach der Bearbeitung aller Agenten, die die Stagnationsschwelle überschritten und die Mutationsbedingung erfüllt haben.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_COA_chaos::ResetStagnatingAgents () { int resetCount = 0; for (int i = 0; i < popSize; i++) { // Increase the stagnation counter if there is no improvement if (a [i].f <= a [i].fB) { agent [i].stagnationCounter++; } else { agent [i].stagnationCounter = 0; } // Reset the agent if it has been stagnating for too long if (agent [i].stagnationCounter > 5) { // Reset only some of the agents with a probability depending on stagnation double resetProb = 0.2 * (1.0 + (double)agent [i].stagnationCounter / 10.0); if (u.RNDprobab () < resetProb) { ApplyMutation (i); agent [i].stagnationCounter = 0; resetCount++; } } } } //——————————————————————————————————————————————————————————————————————————————
Die Methode CalculateWeightedGradient wird verwendet, um den Gradienten einer Nebenbedingung für einen bestimmten Agenten und eine bestimmte Koordinate zu schätzen, wobei der Grad der Verletzung dieser Nebenbedingungen berücksichtigt wird. Sie hilft zu bestimmen, in welche Richtung und in welchem Ausmaß die Lösung angepasst werden sollte, um die Verletzung zu beseitigen, wobei der Gradient nach dem Ausmaß der Verletzung gewichtet wird.
Zunächst werden die Indizes und Koordinaten des Agenten überprüft, um sicherzustellen, dass sie innerhalb akzeptabler Grenzen liegen. Wenn die Indizes unzulässig sind, wird ein Nullwert zurückgegeben, was bedeutet, dass es keine Richtung für die Anpassung gibt. Die Methode durchläuft dann in einer Schleife alle Koordinaten, die mit dem aktuellen Agenten verbunden sind, und berechnet für jede den Wert der Verletzung. Während dieses Prozesses wird nach der größten Verletzung gesucht. Ist die Verletzung für eine bestimmte Koordinate größer als der Schwellenwert „eps“, wird es als sinnvoll erachtet, Korrekturmaßnahmen zu ergreifen; andernfalls wird Null zurückgegeben – eine Bewegung in diese Richtung ist sinnlos oder nicht erforderlich.
Ist die Verletzung signifikant, wird für die Koordinate der Gradient der Nebenbedingung berechnet – ein Maß für die Richtung und Stärke der Änderung der Nebenbedingung im Verhältnis zu Änderungen in dieser Koordinate. Der Gradient wird mit einer Gewichtung multipliziert, die als das Verhältnis zwischen der Verletzung der aktuellen Koordinate und der maximalen Verletzung aller Nebenbedingungen definiert ist. Dadurch wird sichergestellt, dass eine größere Verletzung einen stärkeren Einfluss auf die Richtung der Anpassung hat. Der sich daraus ergebende Wert ist ein gewichteter Nebenbedingungsgradient, der angibt, wie stark und in welche Richtung die Lösung angepasst werden muss, um die Verletzung in einer bestimmten Koordinate zu beseitigen, und zwar proportional zu ihrem Grad.
//—————————————————————————————————————————————————————————————————————————————— double C_AO_COA_chaos::CalculateWeightedGradient (int agentIdx, int coordIdx) { // Calculate the maximum value of the constraint violation double maxViolation = eps; for (int c = 0; c < coords; c++) { double violation = CalculateConstraintValue (agentIdx, c); maxViolation = MathMax (maxViolation, violation); } // Violation for the current coordinate double violation = CalculateConstraintValue (agentIdx, coordIdx); // If there is no significant violation, return 0 if (violation <= eps) return 0.0; // Calculate the gradient double gradient = CalculateConstraintGradient (agentIdx, coordIdx); // Normalize the impact depending on the degree of violation double weight = violation / maxViolation; return gradient * weight; } //——————————————————————————————————————————————————————————————————————————————
Die Methode CalculateConstraintValue wird verwendet, um den Grad der Verletzung der Nebenbedingung für eine bestimmte Koordinate eines bestimmten Agenten abzuschätzen. Sie bestimmt, wie weit der aktuelle Koordinatenwert außerhalb der zulässigen Grenzen liegt und gibt einen numerischen Wert zurück, der das Ausmaß dieser Verletzung widerspiegelt.
Zunächst prüft die Methode die Agentenindizes (agentIdx) und die Koordinaten (coordIdx) auf Gültigkeit. Die Methode holt sich den aktuellen Wert der „x“-Koordinate aus dem Zustand des Agenten und bestimmt auch die minimalen (min) und maximalen (max) akzeptablen Grenzen für diese Koordinate. Anschließend wird geprüft, ob der „x“-Wert innerhalb des zulässigen Bereichs (min und max) liegt. Schließlich gibt die Methode einen Wert von „violation“ zurück, der den Gesamtumfang der Verletzung gegen die Nebenbedingung für die gegebene Koordinate des gegebenen Agenten angibt.
Die wichtigsten Merkmale sind:
- Die Methode gibt einen positiven Wert zurück, wenn die Nebenbedingung verletzt wird, und 0, wenn sie erfüllt ist.
- Das Ausmaß der Verletzung ist proportional zu dem Ausmaß, in dem der Koordinatenwert die zulässigen Grenzen überschreitet.
Letztendlich liefert die CalculateConstraintValue-Methode wichtige Informationen darüber, wie gut jeder Agent in der Population die Problemeinschränkungen erfüllt. Sie misst das Ausmaß der Verletzung, was dem Algorithmus hilft zu verstehen, wie stark die Position des Agenten angepasst werden muss.
//—————————————————————————————————————————————————————————————————————————————— double C_AO_COA_chaos::CalculateConstraintValue (int agentIdx, int coordIdx) { double x = a [agentIdx].c [coordIdx]; double min = rangeMin [coordIdx]; double max = rangeMax [coordIdx]; // Smoothed constraint violation function with a smooth transition at the boundary double violation = 0.0; // Check the lower bound if (x < min) { violation += min - x; } // Check the upper bound else if (x > max) { violation += x - max; } return violation; } //——————————————————————————————————————————————————————————————————————————————
Die Methode CalculateConstraintGradient berechnet den Nebenbedingungsgradienten für eine bestimmte Koordinate eines bestimmten Agenten. Diese Methode bestimmt, in welche Richtung und in welchem Ausmaß der Koordinatenwert aufgrund einer Verletzung der Nebenbedingung geändert werden soll.
Die Methode überprüft zunächst die eingegebenen Agentenindizes (agentIdx) und Koordinaten (coordIdx), um sicherzustellen, dass sie korrekt sind. Liegt mindestens einer der Indizes außerhalb des zulässigen Bereichs, gibt die Methode 0,0 zurück, was bedeutet, dass der Gradient nicht berechnet werden kann. Die Methode ermittelt den aktuellen Wert der Koordinate des Agenten sowie die Mindest- und Höchstgrenzen, die für diese Koordinate festgelegt wurden. Diese Werte werden für weitere Auswertungen benötigt. Anschließend wird geprüft, ob der aktuelle Wert der „x“-Koordinate außerhalb der festgelegten Grenzen liegt.
Der von der Methode zurückgegebene Endwert spiegelt die Richtung und die Notwendigkeit der Änderung des aktuellen Koordinatenwerts des Agenten unter Berücksichtigung der angegebenen Nebenbedingungen wider.
//—————————————————————————————————————————————————————————————————————————————— double C_AO_COA_chaos::CalculateConstraintGradient (int agentIdx, int coordIdx) { double x = a [agentIdx].c [coordIdx]; double min = rangeMin [coordIdx]; double max = rangeMax [coordIdx]; // Smoothed gradient for better stability if (x < min) return -1.0; // Need to increase the value else if (x > max) return 1.0; // Need to decrease the value return 0.0; } //——————————————————————————————————————————————————————————————————————————————
Die Methode CalculatePenaltyFunction berechnet die Werte der Zielfunktion unter Berücksichtigung der Strafe für die Verletzung von Nebenbedingungen für einen bestimmten Agenten. Es kombiniert einen Basiswert der Zielfunktion mit einer Strafe, die auf dem Ausmaß der Verletzung von Nebenbedingungen basiert.
Die Methode beginnt mit der Überprüfung der Gültigkeit des Agentenindex (agentIdx), und wenn der Index zulässig ist, erhält die Methode den (nicht bestraften) Basiswert der Zielfunktion dieses Agenten (a[agentIdx].f) und speichert ihn in der Variablen baseValue. Die Methode durchläuft dann in einer Schleife alle Koordinaten (coords) der einzelnen Agenten. Für jede Koordinate wird das Ausmaß der Verletzung der Nebenbedingung berechnet. Wenn das Ausmaß der Verletzung einen bestimmten kleinen Wert „eps“ überschreitet, wird das Quadrat des Ausmaßes des Verstoßes zur penaltySum-Summe der Strafen hinzugefügt.
Eine quadratische Strafe wird verwendet, um eine „weiche“ Bewertung für geringfügige Verletzungen und eine „harte“ Bewertung für schwerwiegende Verletzungen vorzunehmen. Nachdem alle Strafen für Verletzungen gegen die Nebenbedingungen addiert wurden, wird die gesamte „Strafe“ berechnet.
Schließlich berechnet die Methode den „bestraften“ Wert der Zielfunktion durch Subtraktion der „Strafe“ vom Basiswert der Zielfunktion baseValue. Der bestrafte Wert der Zielfunktion wird zurückgegeben.
//—————————————————————————————————————————————————————————————————————————————— double C_AO_COA_chaos::CalculatePenaltyFunction (int agentIdx) { // Base value of the objective function double baseValue = a [agentIdx].f; // Penalty term double penaltySum = 0.0; for (int c = 0; c < coords; c++) { double violation = CalculateConstraintValue (agentIdx, c); // Quadratic penalty for better resolution of solutions close to the boundary if (violation > eps) { penaltySum += violation * violation; } } // Apply a dynamic penalty ratio double penalty = currentSigma * penaltySum; // For the maximization problem: f_penalty = f - penalty return baseValue - penalty; } //——————————————————————————————————————————————————————————————————————————————
Die Methode Moving ist das das zentrale Verfahren zur Steuerung des Optimierungsablaufs. Es führt sequentielle Schritte durch, die darauf abzielen, den aktuellen Zustand des Systems zu aktualisieren, die Parameter anzupassen und die Suchphasen zu verwalten.
Zunächst wird der aktuelle Epochenzähler inkrementiert. Beim ersten Aufruf initialisiert die Methode die Population und kehrt zurück. Anschließend wird der Strafparameter (sigma) dynamisch aktualisiert, um den Einfluss der Straffunktionen während des Suchprozesses zu regulieren. Eine wichtige Aufgabe besteht darin, Agenten, die feststecken oder keine Fortschritte machen, regelmäßig zu überprüfen und zurückzusetzen, um eine Stagnation in lokalen Fallen zu verhindern.
Die aktuelle Phase der Suche wird dann durch den Wert des Epochenzählers bestimmt – in den ersten Phasen wird eine globale Suche durchgeführt, danach geht es weiter zu einer engeren, lokalen Suche. Je nach Phase werden die entsprechenden Suchstrategien aufgerufen, die die Bewegung der Agenten steuern.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_COA_chaos::Moving () { epochNow++; if (!revision) { InitialPopulation (); revision = true; return; } // Dynamically update the penalty parameter UpdateSigma (); // Reset stagnating agents if (epochNow % 5 == 0) { ResetStagnatingAgents (); } // Determine the search phase if (epochNow <= S1) { FirstCarrierWaveSearch (); } else if (epochNow <= S1 + S2) { SecondCarrierWaveSearch (); } } //——————————————————————————————————————————————————————————————————————————————
Die Revisionsmethode ist für die Verbesserung der Lösungen und die Anpassung der Suchparameter während der iterativen Optimierung zuständig. Sie wertet den aktuellen Zustand der Population erneut aus, aktualisiert die besten Lösungen und passt die Suchparameter auf der Grundlage der Leistung der letzten Schritte an.
Die Methode durchläuft alle Lösungen in der Population und berechnet ihren neuen Strafterm (penalty) mithilfe der Straffunktion, die es ermöglicht, die Verletzungen der Nebenbedingungen zu berücksichtigen. Der sich daraus ergebende Wert wird dann überprüft, und wenn er zulässig ist, wird er als aktueller Wert der Funktion gespeichert. Für jeden Agenten, dessen neuer Funktionswert besser ist als der vorherige, werden seine persönlichen Daten aktualisiert: Der neue Wert wird gespeichert, und die aktuellen Koordinaten werden ebenfalls kopiert. Hier wird die persönlich beste Lösung jedes Agenten gespeichert. Stellt sich heraus, dass ein Agent eine bessere Lösung als die aktuelle globale Lösung hat, wird die globale beste Lösung aktualisiert und die entsprechenden Koordinaten werden gespeichert. Die Historie der besten Lösungen wird ebenfalls aktualisiert.
Nach der ersten Stufe von Iterationen (epochNow > 1) wird der Erfolg der Suche bewertet – der Anteil der Verbesserungen unter allen Agenten wird ermittelt. Auf der Grundlage dieser Bewertung werden die Parameter angepasst, insbesondere „alpha“ (der Suchbereich für jede Koordinate). Je nach aktueller Suchphase (global oder lokal) können die Regeln für die Anpassung von „alpha“ unterschiedlich sein: In der globalen Suchphase wird bei geringer Verbesserung der Suchumfang vergrößert, um die Möglichkeiten zu erweitern; in der lokalen Suchphase wird bei unzureichender Verbesserung der Suchumfang ebenfalls vergrößert. Im Falle eines signifikanten Erfolgs verringert sich der Suchumfang, was zur Lokalisierung der optimalen Lösung beiträgt. Der Parameter „alpha“ wird durch Höchst- und Mindestwerte begrenzt, die auf dem Bereich der akzeptablen Werte für die Koordinate basieren.
Dieser Ansatz ermöglicht ein dynamisches Gleichgewicht zwischen der Erkundung neuer Lösungen und der Lokalisierung optimaler Lösungen unter Verwendung von Informationen über die Leistung früherer Iterationen.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_COA_chaos::Revision () { int improvementCount = 0; double bestImprovement = 0.0; // Evaluate all solutions for (int i = 0; i < popSize; i++) { double newValue = CalculatePenaltyFunction (i); // Check the validity of the new value if (!MathIsValidNumber (newValue)) continue; // Save the current value for the next iteration a [i].f = newValue; // Update the personal best solution (before a global one for efficiency) if (newValue > a [i].fB) { a [i].fB = newValue; ArrayCopy (a [i].cB, a [i].c, 0, 0, WHOLE_ARRAY); improvementCount++; } // Update the global best solution if (newValue > fB) { double improvement = newValue - fB; fB = newValue; ArrayCopy (cB, a [i].c, 0, 0, WHOLE_ARRAY); // Update the history of the best values UpdateBestHistory (fB); bestImprovement = MathMax (bestImprovement, improvement); improvementCount++; } } // Adapt search parameters depending on the phase and success if (epochNow > 1) { // Search success rate (prevention of zero divide) double successRate = (double)improvementCount / MathMax (1, 2 * popSize); // Adaptation of the alpha parameter for (int c = 0; c < coords; c++) { double oldAlpha = alpha [c]; if (epochNow <= S1) { // In the global search phase if (successRate < 0.1) { // Very few improvements - increasing the search scope alpha [c] *= t3; } else if (successRate < 0.3) { // Few improvements - slightly expanding the scope alpha [c] *= 1.2; } else if (successRate > 0.7) { // Many improvements - narrowing the scope alpha [c] *= 0.9; } } else { // In the local search phase if (successRate < 0.05) { // Very few improvements - increasing the search scope alpha [c] *= t3; } else if (successRate > 0.2) { // Enough improvements - narrowing the scope alpha [c] *= 0.8; } } // Limits on alpha range with safe bounds verification if (c < ArraySize (rangeMax) && c < ArraySize (rangeMin)) { double maxAlpha = 0.2 * (rangeMax [c] - rangeMin [c]); double minAlpha = 0.0001 * (rangeMax [c] - rangeMin [c]); if (alpha [c] > maxAlpha) { alpha [c] = maxAlpha; } else if (alpha [c] < minAlpha) { alpha [c] = minAlpha; } } } } } //——————————————————————————————————————————————————————————————————————————————
Nachdem wir nun alle Methoden untersucht haben, können wir direkt mit dem Testen des Algorithmus fortfahren.
Testergebnisse
Die Ergebnisse sprechen für sich: Die externen Parameter wurden leicht optimiert, während die internen Parameter unverändert blieben und wie oben in den Methoden beschrieben dargestellt werden.COA(CHAOS)|Chaos Optimization Algorithm|50.0|10.0|40.0|2.0|1.2|0.0001|
=============================
5 Hilly's; Func runs: 10000; result: 0.6083668756744218
25 Hilly's; Func runs: 10000; result: 0.4079413401686229
500 Hilly's; Func runs: 10000; result: 0.2678056430575926
=============================
5 Forest's; Func runs: 10000; result: 0.668343763134901
25 Forest's; Func runs: 10000; result: 0.38894787694645416
500 Forest's; Func runs: 10000; result: 0.2198998763835145
=============================
5 Megacity's; Func runs: 10000; result: 0.32307692307692304
25 Megacity's; Func runs: 10000; result: 0.1987692307692308
500 Megacity's; Func runs: 10000; result: 0.10598461538461638
=============================
All score: 3.18914 (35.43%)
Ich möchte besonders auf die Visualisierung der Funktionsweise des Algorithmus aufmerksam machen: Die Kombination der verschiedenen verwendeten Suchmethoden erzeugt einen ungewöhnlichen visuellen Effekt.
COA(CHAOS) mit der Testfunktion Hilly
COA(CHAOS) mit der Testfunktion Forest
COA(CHAOS) mit der Testfunktion Megacity
Auf der Grundlage der Testergebnisse wird der COA(CHAOS)-Algorithmus in unserer Bewertungstabelle vorgestellt.
| # | 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-Sperr-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) Evolutionsstrategien | 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 Annealing (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) Evolutionsstrategien | 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 | 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 |
| 30 | 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 |
| 31 | 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 |
| 32 | 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 |
| 33 | 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 |
| 34 | 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 |
| 35 | 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 |
| 36 | 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 |
| 37 | 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 |
| 38 | 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 |
| 39 | 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 |
| 40 | 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 |
| 41 | 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 |
| 42 | 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 |
| 43 | 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 |
| 44 | ASHA | Algorithmus für künstliches Duschen | 0.89686 | 0.40433 | 0.25617 | 1.55737 | 0.80360 | 0.35526 | 0.19160 | 1.35046 | 0.47692 | 0.18123 | 0.09774 | 0.75589 | 3.664 | 40.71 |
| 45 | ASBO | Optimierung des adaptiven Sozialverhaltens | 0.76331 | 0.49253 | 0.32619 | 1.58202 | 0.79546 | 0.40035 | 0.26097 | 1.45677 | 0.26462 | 0.17169 | 0.18200 | 0.61831 | 3.657 | 40.63 |
| CHAOS | Chaos-Optimierungsalgorithmus | 0.60837 | 0.40794 | 0.26781 | 1.28412 | 0.66834 | 0.38895 | 0.21990 | 1.27719 | 0.32308 | 0.19877 | 0.10598 | 0.62783 | 3.189 | 35.43 | |
| 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
Das Ergebnis von 35 % nach den Tests zeigt ein gutes Potenzial des COA(CHAOS)-Algorithmus, insbesondere in Anbetracht seiner Komplexität und der Anzahl der konfigurierbaren externen Parameter, einschließlich der internen Parameter, die nicht optimiert wurden. Der Algorithmus hat einfach noch nicht seine maximale Leistung gezeigt.
Die interessantesten und vielversprechendsten Aspekte des Algorithmus sind die folgenden: die Verwendung von drei verschiedenen Abbildungen (logistisch, sinusförmige und Tent-Abbildungen) für die Suchfähigkeiten des Algorithmus; die Hinzufügung von Trägheit hilft dem Algorithmus, den Schwung beizubehalten, während er lokale Fallen überwindet; dynamische Parameteränderungen, abhängig vom Erfolg und der Phase der Optimierung, erhöhen seine Flexibilität; die Verfolgung des Entscheidungshistorie und das Zurücksetzen von „steckengebliebenen“ Agenten ermöglicht es dem Algorithmus, die Verschwendung von Rechenressourcen auf nicht vielversprechenden Gebieten zu vermeiden. Darüber hinaus gewährleistet die Verwendung des lateinischen Hyperwürfels und verschiedener Ansätze für die anfängliche Platzierung von Agenten von Anfang an eine gute Abdeckung des Suchraums. Um den Algorithmus weiter zu verbessern, wäre es sinnvoll, eine gründlichere Optimierung der internen Parameter vorzunehmen.
Dieser Algorithmus bietet eine reichhaltige Quelle für Ideen zur Verbesserung anderer Optimierungsmethoden, insbesondere seine adaptiven Mechanismen und Methoden zur Behandlung von Stagnation, die erfolgreich auf andere Algorithmen für maschinelles Lernen und Optimierung von Finanzmärkten übertragen werden könnten.
Abbildung 1. Farbskala der Algorithmen nach den entsprechenden Tests
Abbildung 2. 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)
COA(CHAOS) Pro und Kontra:
Vorteile:
- Eine Vielzahl von Suchmethoden.
- Vielversprechende Entwicklung.
- Stabile Ergebnisse.
Nachteile:
- Eine große Anzahl von externen Parametern.
- Eine große Anzahl interner, nicht optimierbarer Parameter.
Dem Artikel ist ein Archiv mit den aktuellen Versionen des Algorithmuscodes beigefügt. Der Autor des Artikels übernimmt keine Verantwortung für die absolute Richtigkeit der Beschreibung der kanonischen Algorithmen. An vielen von ihnen wurden Änderungen vorgenommen, um die Suchmöglichkeiten zu verbessern. Die in den Artikeln dargelegten Schlussfolgerungen und Urteile beruhen auf den Ergebnissen der Versuche.
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_COA_chaos.mq5 | Skript | COA(CHAOS)-Testumgebung |
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/17874
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.
Python + MetaTrader 5: Schnelles Forschungs-Framework für Daten, Merkmale und Prototypen
Forex-Arbitragehandel: Panel zur Bewertung von Wechselkursbeziehungen
Einsatz spieltheoretischer Ansätze in Handelsalgorithmen
Algorithmischer Handel ohne Routine: Schnelle Handelsanalyse im MetaTrader 5 mit SQLite
- 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.
Veröffentlichter Artikel Chaos-Optimierungsalgorithmus (COA): Fortsetzung:
Autor: Andrey Dik
...