Algorithmus der erfolgreichen Gastronomen (SRA)
19
0
Inhalt
Einführung
Ich war schon immer von den Parallelen zwischen Optimierungsproblemen und realen Szenarien fasziniert. Bei der Erforschung neuer Ansätze für metaheuristische Algorithmen entdeckte ich Ähnlichkeiten zwischen der Optimierung von Populationen und der Entwicklung des Gaststättengewerbes, und diese Idee wurde zur Inspiration für das, was ich den Algorithmus der erfolgreichen Gastronomen (Successful Restaurateur Algorithm , SRA) nenne.
Stellen Sie sich einen Restaurantbesitzer vor, der ständig bemüht ist, die Speisekarte zu verbessern, um die Popularität des Restaurants zu steigern und neue Kunden anzuziehen. Anstatt unpopuläre Gerichte komplett zu streichen, wählt unser Restaurantbesitzer einen subtileren Ansatz – er ermittelt das am wenigsten beliebte Gericht und mischt es dann vorsichtig mit Elementen der erfolgreichsten Gerichte. Manchmal werden vorsichtige Änderungen vorgenommen, und manchmal kommen gewagte neue Zutaten hinzu. Das Ziel ist immer dasselbe: aus dem schwächsten Angebot etwas zu machen, das zu einem neuen Favoriten auf der Speisekarte für die Restaurantgäste werden kann.
Diese kulinarische Metapher bildet die Grundlage der SRA. Im Gegensatz zu traditionellen evolutionären Algorithmen, die schlechte Leistungen oft komplett verwerfen, konzentriert sich SRA darauf, schlechte Leistungen zu rehabilitieren, indem sie mit erfolgreichen Elementen gepaart werden. Auf diese Weise bleibt die Vielfalt im Lösungsraum erhalten, während die Gesamtqualität der Population stetig verbessert wird.
In diesem Artikel gehe ich auf die grundlegenden Mechanismen der SRA ein, analysiere ihre Umsetzung und zeige, wie Parameter wie „Temperatur“ und „Intensität der Kochexperimente“ das Gleichgewicht zwischen Nutzen und Erkunden steuern. Ich werde auch Benchmark-Ergebnisse vorstellen, die SRA mit anderen bekannten Algorithmen in der Rangliste bei verschiedenen Testfunktionen vergleichen.
Was als kreatives Gedankenexperiment begann, hat sich zu einem vielversprechenden Ansatz mit einzigartigen Merkmalen entwickelt. Ich lade Sie ein, zu erkunden, wie dieser von Restaurants inspirierte Algorithmus Optimierungslösungen mit einer ganz eigenen Note bietet.
Implementierung des Algorithmus
Lassen Sie uns die Funktionsweise des Algorithmus anhand einfacher Analogien verstehen. Stellen Sie sich vor, ich sei der Besitzer eines Restaurants. Ich habe eine Speisekarte mit verschiedenen Gerichten, und ich stelle fest, dass einige davon sehr beliebt sind, während andere Gerichte von den Gästen fast nie bestellt werden. Was soll ich jetzt tun? Unbeliebte Gerichte nehme ich nicht sofort von der Karte (und würde damit die Liste der verfügbaren Gerichte reduzieren), sondern ich nehme das am wenigsten beliebte Gericht und versuche, es zu verbessern. Wie? Ich schaue mir die Renner des Restaurants an und leihe mir einige Ideen oder Zutaten von dort. Mein Fischgericht zum Beispiel verkauft sich nicht gut, aber mein Salat ist sehr beliebt. Ich nehme Elemente aus einem erfolgreichen Salat (vielleicht ein spezielles Dressing oder eine Serviermethode) und wende sie auf das Fischgericht an. Es stellt sich heraus, dass es etwas Neues ist.
Manchmal nehme ich kleine Änderungen vor, und manchmal beschließe ich, kühne Experimente zu wagen. Am Anfang, als ich das Restaurant eröffnete, habe ich mehr experimentiert, aber als ich ein paar wirklich erfolgreiche Gerichte gefunden hatte, begann ich, die Zusammensetzung der Zutaten und ihre Mengen abzustimmen. Mit der Zeit werden selbst die schwächsten Gerichte auf meiner Speisekarte immer besser. Und manchmal kommt es vor, dass ein ehemaliger Außenseiter nach einigen Änderungen zu einem neuen Erfolgsgericht wird! So wächst die allgemeine Popularität des Restaurants, weil alle Menüpunkte erfolgreich sind.
So funktioniert mein Algorithmus: Ich verwerfe keine schlechten Lösungen, sondern verbessere sie ständig, indem ich Ideen aus den besten Lösungen verwende. Und je weiter wir gehen, desto weniger experimentieren wir, desto mehr verfeinern wir das, was wir bereits gefunden haben. Abbildung 1 zeigt das Funktionsschema des Algorithmus.
Abbildung 1. Flussdiagramm des SRA-Algorithmus
Das Diagramm beginnt mit dem Initialisierungsblock, in dem das Ausgangsmenü erstellt wird. Danach folgt die Hauptschleife des Algorithmus, die sich auf die aktuelle Speisekarte des Restaurants konzentriert, sortiert nach der Qualität der Gerichte. Dieses Menü wird als Farbverlauf von grün (beste Gerichte) bis rot (schlechteste Gerichte) dargestellt. Es folgen vier aufeinanderfolgende Schritte: erstens die Auswahl der zu verbessernden Gerichte, wobei das schlechteste Gericht und der beste Spender mit erhöhter Wahrscheinlichkeit nach einem quadratischen Gesetz ausgewählt werden; zweitens die Schaffung neuer Varianten durch Kombination von Rezepten und Mutation von Zutaten (je höher die Temperatur, desto gewagter die Experimente); drittens die Bewertung der neuen Gerichte durch Berechnung einer Fitnessfunktion; viertens die Senkung der Temperatur, um die Radikalität der Experimente zu verringern. Der gestrichelte Pfeil auf der linken Seite zeigt, dass der Prozess so lange wiederholt wird, bis Konvergenz erreicht oder das Stoppkriterium erfüllt ist. Auf der rechten Seite sind die Bezeichnungen: A (grüner Kreis) – die besten Gerichte, B (roter Kreis) – die schlechtesten Gerichte. Das gesamte Diagramm veranschaulicht einen Prozess, der an einen Gastronomen erinnert, der systematisch schwächere Punkte auf der Speisekarte verbessert, indem er Elemente erfolgreicher Gerichte verwendet.
Gehen wir nun dazu über, den Pseudocode für den SRA-Algorithmus zu schreiben.
// Initialisierung
Erstellen einer Population von popSize-Agenten (Menüpunkte)
Für jeden Agenten:
Zufallsinitialisierung aller Koordinaten innerhalb des zulässigen Bereichs
Einstellen der Anfangstemperatur = 1.0
Einstellen des Abkühlungsrate = 0,98
Setzen Sie die Intensität der kulinarischen Experimente = 0,3
// Die Hauptschleife des Algorithmus
BIS die Anhaltebedingung erfüllt ist:
// Schritt 1: Bewerte alle Agenten
Für jeden Agenten:
Berechne den Wert der Fitnessfunktion
// Zusammenführung der aktuellen und der vorherigen Population
Erstelle ein gemeinsames Menü aus aktuellen und früheren Bearbeitern
Sortiere das allgemeine Menü nach dem Wert der Fitnessfunktion von der besten zur schlechtesten
// Schritt 2: Neue Optionen erstellen
Für jeden Agenten in der neuen Population:
// Nimm das schlechteste Element aus der ersten Hälfte der sortierten Grundgesamtheit
Kopiere die Koordinaten des Agenten mit dem Index (popSize-1)
// Wählen zwischen Verbesserung und Experimentieren
Wenn (Zufallszahl < (1.0 – menuInnovationRate * Temperatur)):
// Wähle einen „Spender“ nach der Methode des quadratischen Roulettes aus.
r = Zufallszahl von 0 bis 1
r = r²
donorIndex = Skala r von 0 bis (popSize-1)
// Für jede Koordinate
Für jede Koordinate c:
// Wir nehmen die Koordinate des Spenders mit einer Wahrscheinlichkeit von 0,8
Wenn (Zufallszahl < 0,8):
current_agent.c = donor.c
// Adaptive Mutation
mutationRate = 0.1 + 0.4 * Temperatur * (agent_index / popSize)
If (Zufallszahl < mutationRate):
// Wählen der Mutationsart
Wenn (Zufallszahl < 0,5):
current_agent.c = Gauß-Verteilung(current_agent.c)
Andernfalls:
current_agent.c = Zufallswert aus dem Bereich
// Sicherstellen, dass der Wert innerhalb akzeptabler Grenzen liegt
current_agent.c = Runden auf den nächsten gültigen Wert
Andernfalls:
// Erstellen eines neuen „Gerichts“
Für jede Koordinate c:
Wenn (Zufallszahl < 0,7):
current_agent.c = Zufallswert aus dem Bereich
Andernfalls:
current_agent.c = Gaußverteilung(beste_Lösung.c)
// Sicherstellen, dass der Wert innerhalb akzeptabler Grenzen liegt
current_agent.c = auf den nächsten gültigen Wert runden
// Elitismus – ein gelegentliches einfaches Hinzufügen von Elementen einer besseren Lösung
Wenn (Zufallszahl < 0,1):
numEliteCoords = Zufallszahl von 1 bis (coords * 0.3)
Für i von 1 bis numEliteCoords:
c = zufälliger Koordinatenindex
current_agent.c = beste_Lösung.c
// Schritt 3: Aktualisiere die beste Lösung.
Für jeden Agenten:
Wenn agent.fitness > best_solution.fitness:
best_solution = agent
// Schritt 4: Temperatur abenken
temperature = temperature * cooling_ratio
Wenn Temperatur < 0,1:
Temperatur = 0,1
Rückgabe beste_Lösung
Jetzt können wir mit dem Schreiben des Algorithmus-Codes beginnen. Schreiben wir die Klasse C_AO_SRA, die von der Hauptklasse C_AO erbt und den SRA-Algorithmus implementiert. Schauen wir uns das genauer an.
Konstruktor und Destruktor: popSize, temperature, coolingRate, menuInnovationRate – diese Parameter bestimmen die Hauptmerkmale des Algorithmus, wie die Anzahl der Agenten und die Parameter der Suchsteuerung.
Methode SetParams: aktualisiert die Klassenparameter auf der Grundlage der im Array „params“ gespeicherten Werte, d.h. der zuvor im Konstruktor initialisierten Parameter.
Methode Init: dient der Initialisierung des Algorithmus. Es nimmt die Minimal- und Maximalwerte, die Schrittweite der Parameter und die Anzahl der Epochen und bereitet den Algorithmus auf die Durchführung der Suchaufgabe vor.
Bewegungs- und Revisionsmethoden: für die Durchführung der wichtigsten Phasen des Algorithmus im Zusammenhang mit der Bewegung (oder Aktualisierung) des Zustands der Agenten und der „Revision“, die für die Überarbeitung und Anpassung der Parameter zuständig ist.
Mitglieder der Klasse:
- temperature – aktuelle Temperatur in Verbindung mit der Studienkontrolle und der Temperaturtabelle des Algorithmus.
- coolingRate – Abkühlungsrate, mit der gesteuert wird, wie schnell die Temperatur sinkt.
- menuInnovationRate – Intensität der kulinarischen Experimente, das Ausmaß, in dem Agenten zur Suche nach neuen Lösungen ermutigt werden.
- S_AO_Agent menu [] – Array von Agenten, das ein „Menü“ im Kontext des SRA-Algorithmus darstellt.
- S_AO_Agent menuT [] – Array von Agenten, die zur vorübergehenden Speicherung von Speiseoptionen verwendet werden.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_SRA : public C_AO { public: //-------------------------------------------------------------------- ~C_AO_SRA () { } C_AO_SRA () { ao_name = "SRA"; ao_desc = "Successful Restaurateur Algorithm (joo)"; ao_link = "https://www.mql5.com/en/articles/17380"; popSize = 50; // number of agents (size of the "menu") temperature = 1.0; // initial "temperature" for research control coolingRate = 0.98; // cooling rate menuInnovationRate = 0.3; // intensity of culinary experiments ArrayResize (params, 4); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "temperature"; params [1].val = temperature; params [2].name = "coolingRate"; params [2].val = coolingRate; params [3].name = "menuInnovationRate"; params [3].val = menuInnovationRate; } void SetParams () { popSize = (int)params [0].val; temperature = params [1].val; coolingRate = params [2].val; menuInnovationRate = params [3].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 temperature; // current "temperature" double coolingRate; // cooling rate double menuInnovationRate; // intensity of culinary experiments private: //------------------------------------------------------------------- S_AO_Agent menu []; S_AO_Agent menuT []; }; //——————————————————————————————————————————————————————————————————————————————
Die Methode Init der Klasse C_AO_SRA initialisiert den Algorithmus:
Initialisierung prüfen: Die Methode ruft StandardInit mit den Minimal- und Maximalwerten der Bereiche und Stufen auf, bei Misserfolg wird „false“ zurückgegeben.
Initialisierung der Arrays:
- Verteilt die Größe der Arrays „menu“ und „menuT“ entsprechend der Anzahl der Bearbeiter.
- Initialisiert jeden Agenten im Array „menu“.
Temperatur-Reset: setzt den Anfangswert der „temperature“ auf „1,0“.
Erfolgreicher Abschluss: gibt „true“ zurück, wenn die Initialisierung erfolgreich war.
//—————————————————————————————————————————————————————————————————————————————— //--- Initialization bool C_AO_SRA::Init (const double &rangeMinP [], const double &rangeMaxP [], const double &rangeStepP [], const int epochsP = 0) { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; //---------------------------------------------------------------------------- ArrayResize (menu, popSize * 2); ArrayResize (menuT, popSize * 2); for (int p = 0; p < popSize * 2; p++) menu [p].Init (coords); temperature = 1.0; // reset temperature during initialization return true; } //——————————————————————————————————————————————————————————————————————————————
Die Methode Moving der Klasse C_AO_SRA implementiert den Hauptschritt des Algorithmus. Es besteht aus zwei Hauptteilen: Initialisierung der Agenten und ihre Anpassung durch Mutation und Schaffung neuer Lösungen.
Erste Initialisierung (wenn „revision“ „false“ ist):- Jeder Agent wird mit Zufallswerten innerhalb bestimmter Bereiche (rangeMin, rangeMax) in Schritten (rangeStep) initialisiert. Die Werte werden in „c“ und „cB“ für jeden Agenten gespeichert.
- “revision“ wird auf „true“ gesetzt und die Methode wird beendet.
Absenken der Temperatur: Die Temperatur wird mit der Abkühlungsrate (coolingRate) multipliziert, was die Wahrscheinlichkeit weiterer Veränderungen beeinflusst.
Die Hauptschleife nach Bearbeitern: Für jeden Bearbeiter wird das schlechteste Element aus der ersten Hälfte der sortierten Grundgesamtheit (aus dem Menüfeld) ausgewählt.
Klassifizierung der Handlungen: Mit einer bestimmten Wahrscheinlichkeit, die von der Temperatur abhängt, kann der Agent entweder:
- die aktuelle Lösung verändern (unter Verwendung des „Spenderrezepts“ des besten Gerichts) und eine Mutation mit unterschiedlicher Wahrscheinlichkeit anwenden oder
- eine neue Lösung erstellen (Zufallswerte).
Elitismus: Mit einer gewissen Wahrscheinlichkeit können Elemente aus der besten gefundenen Lösung zur neuen Lösung hinzugefügt werden.
//—————————————————————————————————————————————————————————————————————————————— //--- The main step of the algorithm void C_AO_SRA::Moving () { //---------------------------------------------------------------------------- // Initial initialization if (!revision) { for (int p = 0; p < popSize; p++) { for (int c = 0; c < coords; c++) { a [p].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); a [p].c [c] = u.SeInDiSp (a [p].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); a [p].cB [c] = a [p].c [c]; } } revision = true; return; } //---------------------------------------------------------------------------- // Lower the temperature temperature *= coolingRate; // Main loop on population agents for (int p = 0; p < popSize; p++) { // Take the worst element from the first half of the sorted population (with index popSize-1) // Remember that items are sorted from best to worst in the menu ArrayCopy (a [p].c, menu [popSize - 1].c, 0, 0, WHOLE_ARRAY); // Decide whether to create a hybrid or experiment with a new "dish" // The probability of an experiment depends on the temperature - there are more experiments at the beginning if (u.RNDprobab () < (1.0 - menuInnovationRate * temperature)) { // Select a "donor-recipe" with a probability proportional to the success of the dish double r = u.RNDprobab (); r = pow (r, 2); // Increased preference for better dishes int menuIND = (int)u.Scale (r, 0, 1.0, 0, popSize - 1); // The best ones are at the beginning of the array // For each coordinate for (int c = 0; c < coords; c++) { // Take the parameter from a successful dish with the probability depending on the temperature if (u.RNDprobab () < 0.8) { a [p].c [c] = menu [menuIND].c [c]; } // Mutation with adaptive probability - the further from the best solution and the higher the temperature, the more mutations double mutationRate = 0.1 + 0.4 * temperature * (double)(p) / popSize; if (u.RNDprobab () < mutationRate) { // Combination of different types of mutations if (u.RNDprobab () < 0.5) a [p].c [c] = u.GaussDistribution (a [p].c [c], rangeMin [c], rangeMax [c], 2); else a [p].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); // Sometimes a completely new value // Make sure the value is within acceptable limits a [p].c [c] = u.SeInDiSp (a [p].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } } } else // Create a completely new "dish" { for (int c = 0; c < coords; c++) { // Variation 1: Completely random value if (u.RNDprobab () < 0.7) { a [p].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); } // Variation 2: based on the best solution found with a large deviation else { a [p].c [c] = u.GaussDistribution (cB [c], rangeMin [c], rangeMax [c], 1); } a [p].c [c] = u.SeInDiSp (a [p].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } } // Sometimes we add elements from the best solution directly (elitism) if (u.RNDprobab () < 0.1) { int numEliteCoords = u.RNDintInRange (1, coords / 3); // Take from 1 to 30% of the coordinates for (int i = 0; i < numEliteCoords; i++) { int c = u.RNDminusOne (coords); a [p].c [c] = cB [c]; // Take the value from the best solution } } } } //——————————————————————————————————————————————————————————————————————————————
Die Methode Revision der Klasse C_AO_SRA ist für die Aktualisierung der besten gefundenen Lösung und für die Verwaltung des gesamten „Menüs“ von Lösungen während des Algorithmusbetriebs verantwortlich:
Suche nach dem besten Agenten: Iteriert durch alle Agenten der aktuellen Population und findet den Agenten mit der besten Fitnessfunktion (f). Wenn ein neuer bester Agent gefunden wird, aktualisieren Sie den fB-Wert und den bestIND-Index.
Aktualisierung der besten Lösung: Wenn der beste Agent gefunden wurde (d.h. bestIND ist ungleich -1), werden seine Entscheidungsparameter (c) in die Variable cB kopiert, die die aktuell beste Entscheidung darstellt.
Aktualisierung des allgemeinen „Menüs“: fügt die aktuellen Parameter aller Agenten in das allgemeine „Menü“ ein, das es Ihnen ermöglicht, abgeschlossene Experimente zu speichern.
Sortieren des Menüs: Sortiert das „Menü“-Array nach der Fitnessfunktion von der besten zur schlechtesten Lösung, wobei sichergestellt wird, dass die besten Lösungen in der ersten Hälfte stehen. Dieser wird bei der nächsten Iteration des Algorithmus verwendet.
Temperaturkontrolle: Legt einen unteren Schwellenwert für die Temperatur fest, sodass sie nicht unter „0,1“ fällt, was eine zu schnelle Konvergenz verhindert.//—————————————————————————————————————————————————————————————————————————————— //--- Update the best solution taking into account greedy selection and the probability of making worse decisions void C_AO_SRA::Revision () { int bestIND = -1; // Find the best agent in the current population for (int p = 0; p < popSize; p++) { if (a [p].f > fB) { fB = a [p].f; bestIND = p; } } // If we find a better solution, update cB if (bestIND != -1) ArrayCopy (cB, a [bestIND].c, 0, 0, WHOLE_ARRAY); // Add the current set of dishes to the general "menu" for (int p = 0; p < popSize; p++) { menu [popSize + p] = a [p]; } // Sort the entire "menu" from best to worst solutions // After sorting, the first half of the menu will contain the best solutions, // which will be used in the next iteration u.Sorting (menu, menuT, popSize * 2); // Prevent the temperature from falling below a certain threshold if (temperature < 0.1) temperature = 0.1; } //——————————————————————————————————————————————————————————————————————————————
Testergebnisse
Jetzt können wir sehen, wie der SRA-Algorithmus funktioniert. Nachstehend finden Sie die Testergebnisse:
SRA|Successful Restaurateur Algorithm|50.0|1.0|0.98|0.3|
=============================
5 Hilly's; Func runs: 10000; result: 0.9688326305968623
25 Hilly's; Func runs: 10000; result: 0.6345483084017249
500 Hilly's; Func runs: 10000; result: 0.292167027537253
=============================
5 Forest's; Func runs: 10000; result: 0.946368863880973
25 Forest's; Func runs: 10000; result: 0.5550607959254661
500 Forest's; Func runs: 10000; result: 0.19124225531141872
=============================
5 Megacity's; Func runs: 10000; result: 0.7492307692307693
25 Megacity's; Func runs: 10000; result: 0.4403076923076923
500 Megacity's; Func runs: 10000; result: 0.12526153846153956
=============================
All score: 4.90302 (54.48%)
Die Visualisierung der Funktionsweise des SRA-Algorithmus auf dem Prüfstand ermöglicht Rückschlüsse auf die charakteristischen Merkmale der Suchstrategie. In diesem Fall beobachten wir eine breite Erkundung des Suchraums: Die Agenten sind gleichmäßig über den gesamten Raum verteilt und erkunden auch die entlegensten Ecken. Gleichzeitig gibt es keine erkennbaren Anzeichen für eine Gruppierung an lokalen Extremen; die Bewegungen der Akteure erscheinen chaotisch.
Trotz seiner guten Explorationsfähigkeit weist der Algorithmus jedoch einige Schwächen bei der Verfeinerung von Lösungen auf, was sich in der relativ geringen Konvergenzgenauigkeit widerspiegelt. Es ist auch zu beachten, dass die Testergebnisse eine geringe Streuung aufweisen.
SRA mit der Testfunktion Hilly
SRA mit der Testfunktion Forest
SRA mit der Testfunktion Megacity
Auf der Grundlage der Testergebnisse belegt der Algorithmus Platz 20 in der Rangliste der stärksten Algorithmen zur Bevölkerungsoptimierung. Die Tabelle enthält derzeit neun proprietäre Optimierungsalgorithmen (joo), darunter den neuen SRA-Algorithmus.
| # | 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) 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 | 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-Spiel-Optimierung | 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 | 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 |
| 43 | 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 |
| 44 | MEC | Evolutionäre Berechnung des Geistes | 0.69533 | 0.53376 | 0.32661 | 1.55569 | 0.72464 | 0.33036 | 0.07198 | 1.12698 | 0.52500 | 0.22000 | 0.04198 | 0.78698 | 3.470 | 38.55 |
| 45 | CSA | Kreis-Such-Algorithmus | 0.66560 | 0.45317 | 0.29126 | 1.41003 | 0.68797 | 0.41397 | 0.20525 | 1.30719 | 0.37538 | 0.23631 | 0.10646 | 0.71815 | 3.435 | 38.17 |
| RW | Random Walk | 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
Nachdem ich den Algorithmus der erfolgreichen Gastronomen (SRA) entwickelt und getestet habe, kann ich mit Zuversicht sagen, dass er sich als erfolgreich erwiesen hat. Derzeit liegt der Algorithmus auf Platz 20 der Rangliste, was für ein neues Konzept recht gut ist. Bei der Analyse der Ergebnisse fielen mir einige Eigenheiten im Verhalten auf. Bei kleindimensionalen Problemen gibt es eine Streuung der Ergebnisse. Besonders auffällig ist dies bei der diskreten Megacity-Funktion, wo der Algorithmus eine besonders große Streuung der Werte aufweist. Diese Funktion ist für Algorithmen sehr schwierig, und das Steckenbleiben in lokalen Extremen ist eher die Regel als die Ausnahme.
Bei hochdimensionalen Problemen zeigt SRA Ergebnisse, die etwas schwächer sind als erwartet. Dies ist wahrscheinlich darauf zurückzuführen, dass in hochdimensionalen Räumen die Strategie zur Verbesserung der schlechtesten Lösungen eine genauere Abstimmung der Parameter Temperatur und Abkühlungsrate erfordert.
Ich halte SRA jedoch für einen brauchbaren Algorithmus mit Potenzial für weitere Verbesserungen. Die kulinarische Metapher macht den Algorithmus nicht nur verständlich, sondern öffnet auch den Weg für intuitive Modifikationen, die Verfeinerung des adaptiven Mutationsmechanismus und die Möglichkeit, mit verschiedenen Schemata für die Auswahl von „Spendergerichten“ zu experimentieren.
Bei der Entwicklung des erfolgreichen Algorithmus für Gastronomen ging es mir nicht so sehr um die Überlegenheit gegenüber bestehenden Optimierungsmethoden, sondern vielmehr darum, durch eine originelle Metapher aus dem wirklichen Leben neue konzeptionelle Horizonte zu eröffnen. Die Ergebnisse der Studie zeigen überzeugend, dass dieser Ansatz seinen Platz im Ökosystem der metaheuristischen Algorithmen verdient hat.
Die Idee, sich auf die schlechteste Lösung in einer Population zu konzentrieren und sie als Grundlage für Experimente zu verwenden – ein Konzept, das auf den ersten Blick verrückt erscheinen mag – hat sich als unerwartet produktiv erwiesen. Gerade dieses Prinzip der „Außenseitersanierung“ offenbart ein erstaunliches Optimierungspotenzial. Wie ein geschickter Gastronom ein unpopuläres Gericht in einen zukünftigen Hit verwandelt, so verwandelt der Algorithmus schwache Lösungen in überlegene, indem er die Zutaten der Erfolgreichen verwendet.
Diese Erfahrung bestätigt eine wertvolle Regel in der wissenschaftlichen Forschung: Auch die unorthodoxesten Ideen können, wenn sie richtig umgesetzt werden, praktischen Nutzen bringen. Unkonventionelle Ansätze decken oft Aspekte eines Problems auf, die bei der Anwendung traditioneller Methoden unbemerkt bleiben.
Abbildung 2. Farbabstufung 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)
Vor- und Nachteile der SRA:
Vorteile:
- Einfache Umsetzung.
- Die Ergebnisse sind gut.
Nachteile
- Keine ernsthaften Nachteile.
Der Artikel wird von einem Archiv mit den aktuellen Versionen der Codes der Algorithmen 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 Suchmöglichkeiten zu verbessern. Die in den Artikeln dargelegten Schlussfolgerungen und Urteile beruhen auf den Ergebnissen der Versuche.
Programme, die im diesem Artikel verwendet werden
| # | Name | Typ | Beschreibung |
|---|---|---|---|
| 1 | #C_AO.mqh | Include | Elternklasse der Populationsoptimierung Algorithmen |
| 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 den Prüfstand |
| 5 | Utilities.mqh | Include | Bibliothek mit Hilfsfunktionen |
| 6 | CalculationTestResults.mqh | Include | Skript zur Berechnung der Ergebnisse in der Vergleichstabelle |
| 7 | Testing AOs.mq5 | Skript | Der einheitliche Prüfstand 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_SRA.mq5 | Skript | SRA-Prüfstand |
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/17380
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.
Neuronale Netze im Handel: Zweidimensionale Verbindungsraummodelle (letzter Teil)
Wie können jahrhundertealte Funktionen Ihre Handelsstrategien aktualisieren?
Indikator für die Stärke eines Währungspaares in reinem MQL5
Billard-Optimierungsalgorithmus (BOA)
- 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.