Kompetitiver Lernalgorithmus (CLA)
13
0
Inhalt
Einführung
In den letzten Jahrzehnten wurden viele bioinspirierte Algorithmen vorgeschlagen, von Ameisenkolonien und Partikelschwärmen bis hin zu Grauwölfen und Walen. Die menschliche Gesellschaft mit ihren komplexen sozialen Interaktionen kann jedoch auch als reiche Ideenquelle für effektive Optimierungsmethoden dienen. Diese Idee ist die Grundlage für den kompetitiven Lernalgorithmus (CLA).
CLA verwendet eine Metapher des Bildungsprozesses, bei der die Population von Lösungen durch Schüler dargestellt wird, die in Klassen organisiert sind. Der Algorithmus modelliert elegant drei Arten des Lernens: vom Besten der Klasse (Lehrer), aus persönlicher Erfahrung und durch klassenübergreifende Interaktion. Dieser Ansatz bietet ein Gleichgewicht zwischen der Erkundung des Suchraums und der Nutzung der gefundenen guten Lösungen, was für eine effektive Optimierung entscheidend ist.
In diesem Artikel untersuchen wir detailliert die Prinzipien des CLA, seine mathematische Grundlage, Implementierungsmerkmale und vergleichen seine Effektivität mit anderen populären Metaheuristiken anhand unserer Standardtestfunktionen.
Implementierung des Algorithmus
Der kompetitive Lernalgorithmus basiert auf einer Metapher des Bildungsprozesses in der Schule. In dieser Metapher repräsentieren Schüler mögliche Lösungen für das Optimierungsproblem, Klassen sind Gruppen von Schülern, Lehrer sind jeweils die besten Schüler ihrer Klasse, Wissen entspricht Koordinaten im Suchraum und die Bewertung entspricht dem Wert der Fitnessfunktion.
Der Algorithmus beginnt mit einer Initialisierung, die mit dem Beginn des Schuljahres verglichen werden kann. Eine Population von beispielsweise 198 Schülern wird erstellt, die in 9 Klassen zu je 22 Schülern unterteilt sind. Jedem Schüler wird zufällig anfängliches „Wissen“ zugewiesen – Koordinaten im Suchraum.
Der Lernprozess ist iterativ, und in jeder Iteration lernen die Schüler auf drei verschiedene Arten. Die erste Methode ist das lehrergeführte Lernen, bei dem jeder Schüler vom Besten seiner Klasse lernt, und je schwächer eine Klasse abschneidet, desto intensiver lernen ihre Schüler, aber mit der Zeit nimmt die Lernintensität für alle ab. Die zweite Methode ist das persönliche Training, das erst nach der vierten Iteration beginnt. In diesem Modus erinnert sich der Schüler an seine besten Ergebnisse der letzten vier „Unterrichtsstunden“ und versucht, zu seiner persönlichen Bestleistung zurückzukehren. Die dritte Methode ist das Lernen von anderen Klassen, das ebenfalls nach der vierten Iteration beginnt. Mit einer Wahrscheinlichkeit von 50 % lernt ein Schüler von dem über alle Klassen hinweg berechneten Durchschnittslehrer, was hilft, ein Steckenbleiben in lokalen Optima zu vermeiden.
Nach jedem Trainingszyklus wird der Fortschritt bewertet. Der beste Schüler jeder Klasse wird identifiziert und zum Lehrer, die Gesamtbewertung der Klasse wird unter Berücksichtigung der Leistung aller Schüler berechnet und die global beste gefundene Lösung wird aktualisiert.
Der Algorithmus verwendet fünf Schlüsselparameter:
- popSize – Gesamtzahl der Schüler,
- numClasses – Anzahl der Klassen,
- beta – Einfluss aller Schüler einer Klasse auf deren Gesamtbewertung,
- gamma – Wahrscheinlichkeit, von anderen Klassen zu lernen,
- deltaIter – Iteration, nach der das erweiterte Lernen unter Nutzung der eigenen Erfahrung und klassenübergreifender Interaktionen beginnt.
Der Algorithmus implementiert mehrere intelligente Mechanismen. Adaptive Lernfaktoren sorgen für intensiveres Lernen bei schwächeren Klassen und eine allmähliche Verlangsamung des Lernens im Zeitverlauf, wie es im realen Bildungsprozess geschieht. Das Gleichgewicht zwischen Exploration und Exploitation wird durch aktive Exploration in den frühen Phasen erreicht, gefolgt von einer Konzentration auf die besten gefundenen Lösungen. Der Speichermechanismus ermöglicht es dem Algorithmus, sich an die Historie jedes Schülers zu erinnern und bei Bedarf zu guten Entscheidungen aus der Vergangenheit zurückzukehren.
Mathematisch lässt sich die Wissensaktualisierung eines Schülers als Summe aus dem aktuellen Wissen und drei Komponenten darstellen: Anleitung durch den Klassenlehrer, persönliche historische Erfahrung und Wissen, das vom Durchschnittslehrer über alle Klassen hinweg gewonnen wurde. Diese Formel bietet ein Gleichgewicht zwischen dem Folgen des Anführers, der Nutzung eigener Erfahrung und der Erforschung neuer Bereiche.
Letztendlich wird die Effektivität des Algorithmus durch mehrere Faktoren bestimmt. Vielfalt wird durch mehrere Klassen erreicht, die unterschiedliche Richtungen im Suchraum erkunden. Der Wettbewerb zwischen Schülern um eine Lehrposition fördert bessere Lösungen. Kooperation durch Wissensaustausch zwischen den Klassen hilft, eine vorzeitige Konvergenz zu verhindern. Adaptivität bietet zusätzliche Hilfe für schwache Klassen, und der Speichermechanismus speichert Informationen über gute Lösungen.
Abb. 1. Funktionsweise des Algorithmus
Die Abbildung der Funktionsweise des Algorithmus zeigt drei Hauptschritte: Initialisierung, Trainingsphase und Evaluierung mit Aktualisierung. Fangen wir nun an, Pseudocode für den CLA_L-Algorithmus zu schreiben.
WAS WIR VORAB BENÖTIGEN:
– 198 Schüler (unsere Lösungen)
– 9 Klassen (Schülergruppen)
– Parameter β = 0,9 (wie wichtig sind alle Schüler in der Klasse)
– Parameter γ = 0,5 (Chance, von anderen Klassen zu lernen)
– Nach der 4. Iteration zusätzliche Lernarten einbeziehen
– Funktion zur Bewertung der Lösungsqualität
FANGEN WIR AN:
1. EINE SCHULE ERSTELLEN:
– 198 Schüler auf 9 Klassen verteilen (je 22)
– Jedem Schüler eine zufällige Anfangsposition im Suchraum zuweisen
– In jeder Klasse den besten Schüler auswählen – er wird zum Lehrer
– Ein Journal erstellen, um die Historie jedes Schülers aufzuzeichnen
2. LERNPROZESS (iterativer Prozess):
Schritt 1: Lernintensität bestimmen
– Für jede Klasse berechnen wir, wie aktiv die Schüler lernen müssen
– Schwache Klassen (mit einem schlechten Rang) lernen intensiver
– Mit der Zeit lernt jeder weniger intensiv (wie im echten Leben)
Schritt 2: Finden des „Durchschnittslehrers“
– Die Positionen aller Lehrer einnehmen
– Den Durchschnittswert berechnen
– Dies wird ein schulweiter Wissensstandard sein
Schritt 3: Jeder Schüler lernt:
Für jeden Schüler:
a) IMMER vom eigenen Lehrer LERNEN:
– Die Position des Klassenlehrers bestimmen
– Sich in deren Richtung bewegen
– Die Schrittweite hängt vom Lernfaktor der Klasse ab
b) Nach der 4. Iteration rufen wir unsere Erfahrung ab:
– Ins Journal schauen: Wo war ich in den letzten 4 Lektionen am besten?
– Mit einer gewissen zufälligen Kraft zu dieser Position zurückkehren
– Dies hilft, gute Lösungen zu bewahren
c) Nach der 4. Iteration von anderen Klassen lernen:
– Werfen einer Münze (mit einer Wahrscheinlichkeit von 50 %)
– Mit einer Wahrscheinlichkeit von 50 % wird auf den „durchschnittlichen Lehrer“ geschaut
– Der Schüler bewegt sich ein Stück in diese Richtung.
– Dies hilft beim Erfahrungsaustausch zwischen den Klassen
Schritt 4: Alle Schüler auswerten
– Jeder Schüler erhält einen Fitnesswert
– Je besser die Position, desto höher der Fitnesswert
Schritt 5: Die Schulhierarchie aktualisieren
Für jede Klasse:
– Einen neuen besten Schüler finden – er wird zum Lehrer
– Den Gesamtwert der Klasse berechnen:
* Den Fitnesswert des Lehrers nehmen
* Den durchschnittlichen Fitnesswert aller Schüler addieren (multipliziert mit β)
– Klassenrang bestimmen:
* Die besten Klassen erhalten einen niedrigen Rang (1, 2, 3...)
* Die schlechtesten Klassen erhalten einen hohen Rang
Schritt 6: Die beste Lösung merken
– Wenn ein Lehrer besser ist als unser Rekordwert
– Als neuen Rekord speichern
Schritt 7: Verlauf speichern
– Die aktuellen Positionen aller Schüler speichern
– Dies wird für das persönliche Training benötigt
3. ABSCHLUSS:
– Rückgabe der besten gefundenen Lösung
– Und dessen Fitnesswert
Beginnen wir nun mit dem Schreiben des Algorithmus-Codes. Die Klasse C_AO_CLA_l erbt von der Basisklasse C_AO und implementiert einen Algorithmus, der auf dem Konzept des kompetitiven Lernens basiert. Die Klasse enthält eine Reihe von benutzerkonfigurierbaren Parametern:
- popSize – Populationsgröße (Anzahl der „Agenten“ oder „Schüler“);
- numClasses – Anzahl der Klassen, in die Agenten unterteilt sind;
- beta – Parameter, der wahrscheinlich die Geschwindigkeit des Lernens oder der Anpassung beeinflusst;
- gamma – ein weiterer Parameter, der sich auf den Lernprozess bezieht;
- deltaIter – die Iterationsnummer, nach der bestimmte Phasen des Algorithmus aktiviert werden.
Der Konstruktor initialisiert die Hauptparameter, legt den Namen und die Beschreibung des Algorithmus fest, setzt Standardwerte für die Variablen und dimensioniert das „params“-Array, das zum Speichern von Informationen über die Algorithmusparameter verwendet wird.
Methoden:
- SetParams() aktualisiert die Werte der internen Variablen der Klasse (Algorithmusparameter) unter Verwendung der Werte aus dem „params“-Array. Dies ermöglicht es, extern festgelegte Parameter zu ändern.
- Init() – initialisiert den Algorithmus. Übernimmt Parameter zur Definition der Grenzen und der Schrittweite der Parameteränderung.
- Moving() – Hauptmethode für das „Bewegen“ von Agenten (Durchführung von Iterationen und Schritten des Algorithmus).
- Revision() – Methode, die mit der Korrektur oder Verbesserung von Entscheidungen verbunden ist.
- Injection() – Methode zum Einfügen von neuem Wissen oder neuen Daten in einen Agenten.
- numClasses, beta, gamma, deltaIter – Algorithmusparameter.
- currentIter, studentsPerClass, totalIters – interne Variablen zur Steuerung des Algorithmusablaufs.
- teachers[] – Array von S_AO_Agent-Strukturen, die die „Lehrer“ in jeder Klasse (Ankerpunkte) repräsentieren.
- classRanks[] – Klassenränge, die deren Leistung widerspiegeln.
- classTotalCosts[] – Gesamtkosten oder „Kosten“ jeder Klasse.
- CL [] – temporäres Array zur Berechnung des durchschnittlichen Wissens der Lehrer.
- UpdateTeachersAndCosts() – interne Methode zur Aktualisierung von Informationen über Lehrer und deren Kosten.
- UpdateClassRanks() – interne Methode zur Aktualisierung von Klassenrängen.
- UpdateStudentsKnowledge() – interne Methode zur Aktualisierung von Wissen oder „Schüler“-Parametern.
//———————————————————————————————————————————————————————————————————— class C_AO_CLA_l : public C_AO { public: //---------------------------------------------------------- ~C_AO_CLA_l () { } C_AO_CLA_l () { ao_name = "CLA_L"; ao_desc = "Competitive Learning Algorithm"; ao_link = "https://www.mql5.com/en/articles/18857"; popSize = 198; numClasses = 3; beta = 0.3; gamma = 0.8; deltaIter = 2; ArrayResize (params, 5); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "numClasses"; params [1].val = numClasses; params [2].name = "beta"; params [2].val = beta; params [3].name = "gamma"; params [3].val = gamma; params [4].name = "deltaIter"; params [4].val = deltaIter; } void SetParams () { popSize = (int)params [0].val; numClasses = (int)params [1].val; beta = params [2].val; gamma = params [3].val; deltaIter = (int)params [4].val; } bool Init (const double &rangeMinP [], const double &rangeMaxP [], const double &rangeStepP [], const int epochsP = 0); void Moving (); void Revision (); void Injection (const int popPos, const int coordPos, const double value) { } //------------------------------------------------------------------ int numClasses; double beta; double gamma; int deltaIter; private: //--------------------------------------------------------- int currentIter; int studentsPerClass; int totalIters; // Structures for classes S_AO_Agent teachers []; double classRanks []; double classTotalCosts []; // Temporary array double CL []; // Average knowledge of teachers // Auxiliary methods void UpdateTeachersAndCosts (); void UpdateClassRanks (); void UpdateStudentsKnowledge (); }; //————————————————————————————————————————————————————————————————————
Die Methode Init() der Klasse C_AO_CLA_l initialisiert den Algorithmus, bevor er mit der Arbeit beginnt. Der Ablauf ist in mehrere Phasen unterteilt. Standardinitialisierung: die Methode StandardInit() wird aufgerufen und führt die Standardinitialisierung für den Optimierungsalgorithmus durch. Sie empfängt die Schrittparameter rangeMinP, rangeMaxP und rangeStepP. Wenn die Standardinitialisierung fehlschlägt, gibt die Methode Init() „false“ zurück.
Initialisierung der Algorithmusparameter: setzt den aktuellen Iterationszähler auf „0“ zurück, legt die Gesamtzahl der Iterationen fest, die der Algorithmus ausführen soll, unter Verwendung des im Argument epochsP übergebenen Wertes, und berechnet die Anzahl der „Schüler“ (Agenten) in jeder Klasse durch Division der Populationsgröße durch die Anzahl der Klassen. Als Nächstes prüft die Methode, ob mindestens ein Schüler in jeder Klasse vorhanden ist. Anschließend initialisiert die „for“-Schleife jeden Agenten in der Population. Für das Array a wird die Methode Init() für jeden Agenten aufgerufen, um dessen Koordinaten-Array zu initialisieren.
Die „for“-Schleife initialisiert einen „Lehrer“ für jede Klasse, setzt den Rang jeder Klasse auf 1.0 und setzt die anfänglichen „Kosten“ jeder Klasse auf einen negativen Maximalwert, um sicherzustellen, dass später eine bessere Lösung gefunden wird. Wenn alle Initialisierungsschritte erfolgreich abgeschlossen wurden, gibt die Methode „true“ zurück.
//———————————————————————————————————————————————————————————————————— bool C_AO_CLA_l::Init (const double &rangeMinP [], const double &rangeMaxP [], const double &rangeStepP [], const int epochsP = 0) { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; //------------------------------------------------------------------ currentIter = 0; totalIters = epochsP; studentsPerClass = popSize / numClasses; if (studentsPerClass < 1) { Print ("Error: Too few students per class"); return false; } // Adjust the population size //spopSize = studentsPerClass * numClasses; ArrayResize (a, popSize); for (int i = 0; i < popSize; i++) a [i].Init (coords); // Initialize class structures ArrayResize (teachers, numClasses); ArrayResize (classRanks, numClasses); ArrayResize (classTotalCosts, numClasses); for (int i = 0; i < numClasses; i++) { teachers [i].Init (coords); classRanks [i] = 1.0; classTotalCosts [i] = -DBL_MAX; } // Temporary array ArrayResize (CL, coords); return true; } //————————————————————————————————————————————————————————————————————
Die Methode Moving() der Klasse C_AO_CLA_l implementiert eine Iteration des Hauptoptimierungsalgorithmus, prüft, ob es sich um die erste Iteration handelt, und falls dies der Fall ist (d. h. „revision“ ist „false“), initialisiert die Methode die Positionen aller Agenten in der Population auf Zufallswerte im angegebenen Bereich. Sie iteriert über alle Agenten in der Population und für jeden Agenten über alle seine Koordinaten.
Für jede Koordinate generiert die Methode einen Zufallswert „val“ im Bereich von rangeMin[c] bis rangeMax[c], unter Verwendung der Methode u.RNDfromCI(), die eine Funktion zur Generierung von Zufallszahlen bereitstellt. Sie weist val der Koordinate a[i].c[c] des Agenten i zu, nachdem sie ihn zuvor begrenzt hat, sodass er innerhalb des zulässigen Bereichs liegt und dem angegebenen Schritt rangeStep[c] entspricht. Die Methode u.SeInDiSp() wird verwendet, die eine Überprüfung und Anpassung der Werte durchführt.
Nach der Initialisierung der Population wird ein Flag gesetzt, um anzuzeigen, dass die Initialisierung durchgeführt wurde. Wenn dies nicht die erste Iteration ist, wird der aktuelle Iterationszähler inkrementiert. Die Methode UpdateStudentsKnowledge() wird aufgerufen, um den Hauptmechanismus für das Training oder die Anpassung von Agenten gemäß den Prinzipien des kompetitiven Lernens, die im CLA_L-Algorithmus verwendet werden, zu implementieren. Die Logik dieser Methode bestimmt, wie Agenten interagieren, Informationen austauschen und ihre Positionen im Suchraum der Lösungen verbessern.
//———————————————————————————————————————————————————————————————————— void C_AO_CLA_l::Moving () { // Initial population setup if (!revision) { for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { double val = u.RNDfromCI (rangeMin [c], rangeMax [c]); a [i].c [c] = u.SeInDiSp (val, rangeMin [c], rangeMax [c], rangeStep [c]); } } revision = true; return; } currentIter++; // Update students' knowledge UpdateStudentsKnowledge (); } //————————————————————————————————————————————————————————————————————
Die Methode UpdateStudentsKnowledge() ist für die Aktualisierung der Position jedes Schülers (Agenten) während der Optimierung verantwortlich. Der aktuelle Optimierungsfortschritt wird berechnet. Zwei wichtige Lernfaktoren werden berechnet:
- TF (Teaching Factor) – zeigt, wie viel ein Schüler von einem Lehrer lernt.
- CF (Confirmatory Factor) – zeigt das Ausmaß, in dem ein Schüler das Durchschnittswissen der Lehrer berücksichtigt. Diese Faktoren hängen vom Fortschritt des Schülers und dem Klassenrang ab.
Als Nächstes wird der Durchschnittswert der Koordinaten aller „aktiven“ Lehrer (Lehrer, deren Fitnesswert gültig ist) berechnet. Dieses Durchschnittswissen wird in einem temporären Array gespeichert. Für jeden Schüler (Agenten) wird die Klasse bestimmt, der der Schüler angehört, und für jede Koordinate des Schülers wird eine neue Schülerposition berechnet, indem die aktuelle Koordinate mit den „Wissensquellen“ summiert wird. Der Schüler lernt von seinem Lehrer, indem er seine Position um einen Betrag anpasst, der proportional zur Differenz zwischen der Koordinate des Lehrers und seiner eigenen ist, multipliziert mit TF. Wenn genügend Iterationen vergangen sind (currentIter > deltaIter) und der Schüler eine „beste Lösung“ hat, lernt der Schüler aus seiner früheren erfolgreichen Erfahrung, indem er seine Position in Richtung der besten Koordinate anpasst, multipliziert mit einem Zufallsfaktor.
Wenn genügend Iterationen vergangen sind und die Anzahl der Lehrer gültig ist, lernt der Schüler aus dem Durchschnittswissen aller Lehrer und passt seine Position in Richtung der durchschnittlichen Koordinate, multipliziert mit CF, mit einer gewissen Wahrscheinlichkeit (1-gamma) an. Grenzen (Beschränkungen) werden auf jede Schüler-Koordinate angewendet, um sicherzustellen, dass der Wert innerhalb des zulässigen Bereichs liegt. Der Wert wird angepasst, um den zulässigen Werten unter Berücksichtigung der Schrittweite des Suchraums zu entsprechen.
//———————————————————————————————————————————————————————————————————— void C_AO_CLA_l::UpdateStudentsKnowledge () { // Calculate learning factors for the current iteration double progress = (double)currentIter / (double)MathMax (totalIters, 100); // Calculate the average knowledge of all teachers (CL) ArrayInitialize (CL, 0.0); int validTeachers = 0; for (int k = 0; k < numClasses; k++) { // Make sure the teacher is initialized if (teachers [k].f > -DBL_MAX) { for (int c = 0; c < coords; c++) { CL [c] += teachers [k].c [c]; } validTeachers++; } } if (validTeachers > 0) { for (int c = 0; c < coords; c++) { CL [c] /= validTeachers; } } // Update each student for (int i = 0; i < popSize; i++) { int classIdx = i / studentsPerClass; // Teaching Factor - decreases with progress double TF = MathExp (-0.6 * progress * classRanks [classIdx]); TF = MathMax (0.1, MathMin (1.0, TF)); // Confirmatory Factor double CF = MathExp (-0.5 * progress * classRanks [classIdx]); CF = MathMax (0.1, MathMin (1.0, CF)); // Update the student position for (int c = 0; c < coords; c++) { double newPos = a [i].c [c]; // a) Teacher Learning - learn from the class teacher if (teachers [classIdx].f > -DBL_MAX) { newPos += TF * (teachers [classIdx].c [c] - a [i].c [c]); } // b) Personal Learning - learn from your best solution if (currentIter > deltaIter && a [i].fB > -DBL_MAX) { double PF = u.RNDprobab (); newPos += PF * (a [i].cB [c] - a [i].c [c]); } // c) Confirmatory Learning - learn from the average of all teachers if (currentIter > deltaIter && validTeachers > 0) { double rnd = u.RNDprobab (); if (rnd >= gamma) // Participate with probability (1-gamma) { newPos += CF * (CL [c] - a [i].c [c]); } } // Apply borders a [i].c [c] = u.SeInDiSp (newPos, rangeMin [c], rangeMax [c], rangeStep [c]); } } } //————————————————————————————————————————————————————————————————————
Die Methode Revision() in der Klasse C_AO_CLA_l wird verwendet, um Informationen über die besten Lösungen jedes Agenten zu aktualisieren sowie die globale beste Lösung und die entsprechenden Parameter zu aktualisieren.
Für jeden Agenten wird geprüft, ob sich sein aktueller Zielfunktionswert (a[i].f) im Vergleich zu seinem gespeicherten besten Wert (a[i].fB) verbessert hat. Falls ja, wird der beste Wert gespeichert und die entsprechenden Koordinaten werden kopiert. Nach der Überprüfung aller Agenten werden die globalen Parameter aktualisiert, falls einer von ihnen einen besseren Funktionswert als das aktuelle globale Maximum (fB) erzielt hat: fB ist der global beste Funktionswert und cB sind die Koordinaten dieser besten Lösung.
Als Nächstes wird die Methode UpdateTeachersAndCosts() aufgerufen, die Informationen über die besten Lehrer aktualisiert. Am Ende wird UpdateClassRanks() aufgerufen, um die Klassenränge neu zu berechnen, was die Priorität bei der Auswahl bestimmter Lösungen in nachfolgenden Iterationen beeinflusst.
//———————————————————————————————————————————————————————————————————— void C_AO_CLA_l::Revision () { for (int i = 0; i < popSize; i++) { // Update personal best positions if (a [i].f > a [i].fB) { a [i].fB = a [i].f; ArrayCopy (a [i].cB, a [i].c); } // Update the global best one if (a [i].f > fB) { fB = a [i].f; ArrayCopy (cB, a [i].c); } } // Update teachers UpdateTeachersAndCosts (); // Update class ranks UpdateClassRanks (); } //————————————————————————————————————————————————————————————————————
Die Methode UpdateTeachersAndCosts() wird verwendet, um Informationen über Lehrer in jeder Klasse zu aktualisieren und die Gesamtkosten der Klasse zu berechnen. Die Methode durchläuft alle im System definierten Klassen. Für jede Klasse werden die Anfangs- und Endindizes der in dieser Klasse enthaltenen Schüler (Agenten) bestimmt.
Um den besten Schüler der Klasse zu finden, werden Variablen initialisiert, um den besten Funktionswert, den Index des besten Schülers, die Summe der Funktionswerte aller Schüler in der Klasse und die Anzahl der gültigen Schüler zu speichern. Der Zyklus durchläuft alle Schüler in der aktuellen Klasse. Für jeden Schüler wird geprüft, ob seine Lösung gültig ist, und wenn die Lösung gültig ist, dann: der Fitnesswert des Schülers wird zu sumFitness addiert, der Zähler der gültigen Schüler wird erhöht, und wenn der Fitnesswert des aktuellen Schülers besser als der aktuelle Bestwert bestFitness ist, dann wird dieser aktualisiert und bestIdx wird aktualisiert.
Nachdem der beste Schüler der Klasse gefunden wurde, wird geprüft, ob es mindestens einen gültigen Schüler in der Klasse gab (validStudents > 0). Wenn die Bedingung erfüllt ist, werden die Koordinaten des besten Schülers in die Koordinaten des Lehrers der entsprechenden Klasse kopiert und der Wert der Funktion des besten Schülers wird dem Wert der Funktion des Lehrers zugewiesen.
Der Durchschnittswert der Funktion aller Schüler in der Klasse avgFitness wird berechnet. Die gesamten „Kosten“ der Klasse werden als Summe aus dem Wert der Funktion des besten Schülers und dem Produkt aus dem „Beta“-Koeffizienten und dem Durchschnittswert der Funktion aller Schüler berechnet. Es ist eine Kombination aus Lehrereffektivität und der durchschnittlichen Klassenleistung.
//———————————————————————————————————————————————————————————————————— void C_AO_CLA::UpdateTeachersAndCosts () { for (int k = 0; k < numClasses; k++) { int startIdx = k * studentsPerClass; int endIdx = startIdx + studentsPerClass; double bestFitness = -DBL_MAX; int bestIdx = startIdx; double sumFitness = 0.0; int validStudents = 0; // Find the best student (teacher) in the class for (int i = startIdx; i < endIdx; i++) { if (a[i].f > -DBL_MAX) // Validity check { sumFitness += a[i].f; validStudents++; if (a[i].f > bestFitness) { bestFitness = a[i].f; bestIdx = i; } } } // Update the teacher if (validStudents > 0) { ArrayCopy (teachers[k].c, a[bestIdx].c); teachers[k].f = bestFitness; // Calculate the class total cost double avgFitness = sumFitness / validStudents; classTotalCosts[k] = bestFitness + beta * avgFitness; } } } //————————————————————————————————————————————————————————————————————
Die Methode UpdateClassRanks() wird verwendet, um die Ränge der Klassen basierend auf ihren Gesamtkosten zu bestimmen, was charakterisiert, wie effektiv die Klasse ist. Der Prozess beginnt mit der Ermittlung der minimalen und maximalen Kosten unter allen gültigen Klassen. Wenn alle Klassen denselben Wert haben oder keine gültigen Klassen vorhanden sind, wird für alle derselbe Rang 1 festgelegt.
Wenn es Unterschiede bei den Kosten gibt, werden diese Werte normalisiert – jeder Kostenwert wird auf einen Bereich von 0 bis 1 normiert. Danach wird eine Inversion durchgeführt: Klassen mit höheren Kosten erhalten einen niedrigeren Rang nahe 1, und solche mit niedrigeren Kosten erhalten einen maximalen Rang, der der Anzahl der Klassen entspricht.
Jeder Rangwert wird dann auf einen Minimal- und Maximalwert begrenzt, um Werte außerhalb des zulässigen Bereichs zu vermeiden. Letztendlich werden den Klassen basierend auf den Ergebnissen dieser Methode Ränge entsprechend ihrer Leistung zugewiesen.
//———————————————————————————————————————————————————————————————————— void C_AO_CLA_l::UpdateClassRanks () { // Find the min and max costs among valid classes double minCost = DBL_MAX; double maxCost = -DBL_MAX; int validClasses = 0; for (int k = 0; k < numClasses; k++) { if (classTotalCosts [k] > -DBL_MAX) { if (classTotalCosts [k] < minCost) minCost = classTotalCosts [k]; if (classTotalCosts [k] > maxCost) maxCost = classTotalCosts [k]; validClasses++; } } if (validClasses == 0 || maxCost - minCost < 1e-10) { // All classes have the same score for (int k = 0; k < numClasses; k++) classRanks [k] = 1.0; } else { // Ranking: best classes (high cost) get low rank for (int k = 0; k < numClasses; k++) { if (classTotalCosts [k] > -DBL_MAX) { // Normalize from 0 to 1 double normalized = (classTotalCosts [k] - minCost) / (maxCost - minCost); // Inversion: the best get a rank close to 1 classRanks [k] = 1.0 + (1.0 - normalized) * (numClasses - 1.0); // Limitation classRanks [k] = MathMax (1.0, MathMin ((double)numClasses, classRanks [k])); } else { classRanks [k] = numClasses; // Worst rank for uninitialized } } } } //————————————————————————————————————————————————————————————————————
Testergebnisse
Dem Test zufolge liefert der CLA_L-Algorithmus recht gute Ergebnisse.CLA_L|Competitive Learning Algorithm|198.0|3.0|0.3|0.8|2.0|
=============================
5 Hilly's; Func runs: 10000; result: 0.6482993681242128
25 Hilly's; Func runs: 10000; result: 0.5535249826770444
500 Hilly's; Func runs: 10000; result: 0.2584959913710746
=============================
5 Forest's; Func runs: 10000; result: 0.8027208362980616
25 Forest's; Func runs: 10000; result: 0.49540442971179494
500 Forest's; Func runs: 10000; result: 0.20048686632188017
=============================
5 Megacity's; Func runs: 10000; result: 0.6353846153846153
25 Megacity's; Func runs: 10000; result: 0.2716923076923076
500 Megacity's; Func runs: 10000; result: 0.10086153846153936
=============================
All score: 3.96687 (44.08%)
Die Visualisierung zeigt, dass der Algorithmus anfangs gute Suchfähigkeiten aufweist, die sich jedoch aufgrund lokaler Fallen verschlechtern, was in der zweiten Hälfte des Algorithmusbetriebs zu einer Stagnation führt.
CLA_L mit der Testfunktion Hilly
CLA_L mit der Testfunktion Forest
CLA_L mit der Testfunktion Megacity
Basierend auf den Ergebnissen der Arbeit des Algorithmus wird die CLA_L-Rangliste zu Informationszwecken bereitgestellt.
| # | 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) 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 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 | EOm | extremal_optimization_M | 0.76166 | 0.77242 | 0.31747 | 1.85155 | 0.99999 | 0.76751 | 0.23527 | 2.00277 | 0.74769 | 0.53969 | 0.14249 | 1.42987 | 5.284 | 58.71 |
| 13 | BBO | biogeografisch basierte Optimierung | 0.94912 | 0.69456 | 0.35031 | 1.99399 | 0.93820 | 0.67365 | 0.25682 | 1.86867 | 0.74615 | 0.48277 | 0.17369 | 1.40261 | 5.265 | 58.50 |
| 14 | 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 |
| 15 | 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 |
| 16 | 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 |
| 17 | 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 |
| 18 | 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 |
| 19 | 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 |
| 20 | 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 |
| 21 | BSA | Backtracking-Suchalgorithmus | 0.97309 | 0.54534 | 0.29098 | 1.80941 | 0.99999 | 0.58543 | 0.21747 | 1.80289 | 0.84769 | 0.36953 | 0.12978 | 1.34700 | 4.959 | 55.10 |
| 22 | 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 |
| 23 | 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 |
| 24 | 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 |
| 25 | 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 |
| 26 | 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 |
| 27 | DEA | Algorithmus zur Echoortung bei Delfinen | 0.75995 | 0.67572 | 0.34171 | 1.77738 | 0.89582 | 0.64223 | 0.23941 | 1.77746 | 0.61538 | 0.44031 | 0.15115 | 1.20684 | 4.762 | 52.91 |
| 28 | 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 |
| 29 | 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 |
| 30 | 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 |
| 31 | 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 |
| 32 | (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 |
| 33 | 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 |
| 34 | 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 |
| 35 | 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 |
| 36 | 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 |
| 37 | 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 |
| 38 | 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 |
| 39 | CAm | Kamel-Algorithmus 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 |
| 40 | 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 |
| 41 | CMAES | Anpassung der Kovarianzmatrix mittels Evolutionsstrategie | 0.76258 | 0.72089 | 0.00000 | 1.48347 | 0.82056 | 0.79616 | 0.00000 | 1.61672 | 0.75846 | 0.49077 | 0.00000 | 1.24923 | 4.349 | 48.33 |
| 42 | 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 |
| 43 | 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 |
| 44 | 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 |
| 45 | 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 |
| CLA_L | Algorithmus des kompetitiven Lernens | 0.64829 | 0.55352 | 0.25849 | 1.46030 | 0.80272 | 0.49540 | 0.20048 | 1.49860 | 0.63538 | 0.27169 | 0.10086 | 1.00793 | 3.967 | 44.08 | |
| 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
Der wettbewerbsorientierte Lernalgorithmus (CLA_L) zeigt eine durchschnittliche Leistung bei der Lösung von Standardoptimierungsproblemen. Die Analyse der Funktionsweise des Algorithmus ergab eine charakteristische Zweiphasendynamik: eine aktive Explorationsphase in den ersten Iterationen und eine vorzeitige Stagnationsphase in der zweiten Hälfte des Optimierungsprozesses.
Die Unterteilung der Population in Klassen gewährleistet eine gute Abdeckung des Suchraums in den frühen Stadien. Jede Klasse erkundet ihren eigenen Bereich, was zu einer globalen Suche beiträgt. Das Bildungsmodell macht den Algorithmus anschaulich und leicht interpretierbar. Die Konzepte von Lehrern, Schülern und verschiedenen Lernarten sind natürlich zu verstehen. Lernfaktoren, die vom Klassenrang abhängen, sollten theoretisch ein Gleichgewicht zwischen Exploration und Exploitation bieten. Die Kombination aus drei Lernarten (Lehrerlernen, persönliches Lernen und Lernen vom durchschnittlichen Lehrer) schafft das Potenzial, lokale Optima zu vermeiden. Trotz der Diversifizierungsmechanismen neigt der Algorithmus dazu, in lokalen Optima stecken zu bleiben.
Der CLA-Algorithmus stellt ein interessantes Konzept dar, eine Bildungsmetapher auf Optimierungsprobleme anzuwenden. Trotz des innovativen Ansatzes und der guten Anfangsleistung erfordert der Algorithmus erhebliche Modifikationen, um mit modernen Metaheuristiken konkurrenzfähig zu sein. Die größte Herausforderung bleibt die Gewährleistung eines Gleichgewichts zwischen Exploration und Exploitation während des gesamten Optimierungsprozesses.
Abbildung 2. Farbcodierung der Algorithmen nach Test
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 von CLA_L:
Vorteile:
- Schnell.
Nachteile:
- Eine große Anzahl von externen Parametern.
- Neigt dazu, in lokalen Optima stecken zu bleiben.
Dem Artikel ist ein Archiv mit den aktuellen Versionen der 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 Experimente.
Im Artikel verwendete Programme
| # | 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_CLA_L.mq5 | Skript | CLA_L-Teststand |
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/18857
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.
Die Übertragung der Trading-Signale in einem universalen Expert Advisor.
Von der Grundstufe bis zur Mittelstufe: Arbeiten mit Dateien in der Sandbox von MetaTrader 5
Eine alternative Log-datei mit der Verwendung der HTML und CSS
Quantenneuronales Netz in MQL5 (Teil I): Erstellen der Include-Datei
- 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.