Diskussion zum Artikel "Algorithmen zur Optimierung mit Populationen: Saplings Sowing and Growing up (SSG)" - Seite 12
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
Ja, ein sehr interessanter Organismus.))
Aber die Schnecke verwendet nur 2 Dimensionen, und selbst die einfachsten AOs kommen mit 2 Dimensionen zurecht. Wie sie sich in 1000 Dimensionen verhalten wird, ist eine große Frage, denn die Komplexität des Problems wächst nicht linear mit der Anzahl der Dimensionen.
Der Schleimpilz-Algorithmus ist eine heuristische Optimierungsmethode, die auf dem Verhalten von Schleimpilzen basiert. Dieser Algorithmus wurde von Chiaro D'Ambrosio entwickelt und gehört zur Gruppe der "natürlichen" Optimierungsalgorithmen.
Das Wesen des Algorithmus besteht darin, eine "Schnecke" an einem bestimmten Punkt zu platzieren und zu beobachten, wie sie sich auf der Suche nach einem Maximum an Nahrung um diesen Punkt herum ausbreitet. Im Verlauf dieses Algorithmus hinterlässt die Schnecke eine Spur, die sich nach und nach verflüchtigt. Je mehr Spuren sie in einem Gebiet hinterlässt, desto wahrscheinlicher ist es, dass eine andere "Schnecke" diese Spur als Weg zu einer höheren Nahrungskonzentration nimmt.
Im Zusammenhang mit der Optimierung wird dieses Schneckenverhalten genutzt, um optimale Lösungen in Parameterräumen zu finden. Wir können diesen Algorithmus zum Beispiel verwenden, um den Mindestwert einer Funktion innerhalb bestimmter Parametergrenzen zu finden.
Die Vorteile dieses Algorithmus sind seine Einfachheit und seine Fähigkeit, schnell zu optimalen Lösungen in mehrdimensionalen Räumen zu konvergieren. Allerdings kann er bei komplexeren und nichtlinearen Problemen auch Probleme mit der Konvergenz zur optimalen Lösung haben.
Der Ameisenalgorithmus ist derselbe, aber er ist auf mehrdimensionale Fälle verallgemeinert.
Die Konvergenz der Ameise nimmt mit zunehmender Dimensionalität ab, sie nimmt schnell ab. alle Algorithmen verhalten sich im Allgemeinen gleich. es hängt von der Suchstrategie ab, und wir kennen die Strategie der Schnecke nicht))).
Die Konvergenz nimmt mit zunehmender Dimensionalität langsamer ab als der Komplexitätszuwachs - ich betrachte die AO-Skalierbarkeit. Die Skalierbarkeit hängt von der Art der Funktion ab, verschiedene Algorithmen skalieren bei verschiedenen Funktionen unterschiedlich.
Der Schleimpilz-Algorithmus ist eine heuristische Optimierungsmethode, die auf dem Verhalten von Schleimpilzen basiert. Dieser Algorithmus wurde von Chiaro D'Ambrosio entwickelt und gehört zur Gruppe der "natürlichen" Optimierungsalgorithmen.
Das Wesen des Algorithmus besteht darin, eine "Schnecke" an einem bestimmten Punkt zu platzieren und zu beobachten, wie sie sich auf der Suche nach einem Maximum an Nahrung um diesen Punkt herum ausbreitet. Im Verlauf dieses Algorithmus hinterlässt die Schnecke eine Spur, die sich nach und nach verflüchtigt. Je mehr Spuren sie in einem Gebiet hinterlässt, desto wahrscheinlicher ist es, dass eine andere "Schnecke" diese Spur als Weg zu einer höheren Nahrungskonzentration nimmt.
Im Zusammenhang mit der Optimierung wird dieses Schneckenverhalten genutzt, um optimale Lösungen in Parameterräumen zu finden. Wir können diesen Algorithmus zum Beispiel verwenden, um den Mindestwert einer Funktion innerhalb bestimmter Parametergrenzen zu finden.
Die Vorteile dieses Algorithmus sind seine Einfachheit und seine Fähigkeit, schnell zu optimalen Lösungen in mehrdimensionalen Räumen zu konvergieren. Allerdings kann er bei komplexeren und nichtlinearen Problemen auch Probleme haben, zur optimalen Lösung zu konvergieren.
wow, wie interessant. ich werde nach diesem algo suchen, natürlich ist es interessant, ihn auseinander zu nehmen. und assemble)))))))
wow, wie interessant. Ich werde nach diesem Algo suchen, natürlich ist es interessant, es auseinander zu nehmen. und zusammenbauen))))))
Hier ist ein Beispiel für die Implementierung des Slug-Algorithmus in der Programmiersprache MQL:
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0.1; // Verdunstungskoeffizient verfolgen
const double stepSize = 0.001; // Größe des "Slug"-Bewegungsschritts
double trail[N]; // Array mit den Spuren der einzelnen Partikel
double bestTrail[N]; // Array der besten Spur
double bestFitness = DBL_MAX; // Anfangswert der besten Fitnessfunktion
double bestX[N]; // Array von Parameterwerten entsprechend der besten Spur
for (int i = 0; i < N; i++) {
for (int j = 0; j < n; j++) {
x[j] = LB[j] + (UB[j] - LB[j]) * (double)rand() / RAND_MAX; // "Slugs" zufällig im angegebenen Parameterbereich platzieren
}
trail[i] = f(x); // Berechnung des Wertes der Fitnessfunktion für diese Parameter
if (trail[i] < bestFitness) { // wenn der Wert der Fitnessfunktion besser ist als der aktuelle beste Wert, wird er als neuer bester Wert gespeichert
bestFitness = trail[i];
memcpy(bestX, x, sizeof(bestX)); // Kopieren der Werte der gefundenen Parameter in das Array der besten Werte
memcpy(bestTrail, trail, sizeof(bestTrail)); // kopiert Funktionswerte für die gefundenen Parameter in das Array der besten Funktionswerte
}
}
for (int iter = 0; iter < maxIter; iter++) { // Schleife um die Anzahl der Iterationen
for (int i = 0; i < N; i++) {
double r[n], d[n];
for (int j = 0; j < n; j++) {
r[j] = (double)rand() / RAND_MAX - 0,5; // Vektor für Zufallsinkremente
d[j] = r[j] * stepSize * (UB[j] - LB[j]); // Berechnung der Schrittweite
x[j] += d[j]; // Hinzufügen eines Schritts zu dem Parameter
if (x[j] < LB[j]) { // wenn der Parameter außerhalb des Bereichs liegt, ihn an der Grenze belassen
x[j] = LB[j];
} else if (x[j] > UB[j]) {
x[j] = UB[j];
}
}
double newTrail = f(x); // Berechnung des Funktionswertes für die neuen Parameter
if (newTrail <= trail[i]) { // wenn sich der Funktionswert verbessert oder nicht geändert hat, die neuen Parameter und den Funktionswert speichern
memcpy(bestX, x, sizeof(bestX)); // Kopieren der neuen Parameter in das Array der besten Parameterwerte
memcpy(bestTrail, &newTrail, sizeof(newTrail)); // Kopieren des neuen Funktionswertes in das Array der besten Funktionswerte
trail[i] = newTrail; // speichert den Funktionswert für neue Parameter in das Array der Funktionswerte für alle "Slugs"
if (bestTrail[i] < bestFitness) { // prüfen, ob die aktuelle beste Lösung besser ist als die aktuelle beste Lösung
bestFitness = bestTrail[i];
}
} else { // wenn sich die Funktionswerte verschlechtert haben, zurück zu den alten Parametern
memcpy(x, bestX, sizeof(bestX));
trail[i] = bestTrail[i];
}
}
for (int i = 0; i < N; i++) {
trail[i] *= (1.0 - k); // den Slug-Trail eindampfen, um nicht im lokalen Maximum stecken zu bleiben
}
}
return bestFitness;
}
```
Dieser Code verwendet zufällige Werte ausgewählter Parameter als Startpunkt und verarbeitet dann jedes Partikel nacheinander. Für jedes Partikel wird ein zufälliger Inkrementvektor erzeugt, die Schrittweite berechnet und zu jedem Parameter hinzugefügt. Anschließend berechnet es den Funktionswert für die neuen Parameter und speichert ihn, wenn der Wert sinkt oder gleich bleibt. Am Ende eines jeden Zyklus wird die Schleppkurve verdampft, um zu verhindern, dass sie an einem lokalen Maximum hängen bleibt.
Wahrscheinlich müssen Sie es dort anpassen 😀 gpt ausgegeben
Sie haben recht, es gibt keine `memcpy`-Funktion in MQL. Um Werte von einer Variablen in eine andere zu kopieren, können Sie den Zuweisungsoperator `=` verwenden. Hier ist ein Beispiel des geänderten Codes ohne Verwendung der Funktion `memcpy`:
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0.1; // Verdunstungskoeffizient verfolgen
const double stepSize = 0.001; // Größe des "Slug"-Bewegungsschritts
double trail[N]; // Array mit den Spuren der einzelnen Partikel
double bestTrail[N]; // Array der besten Spur
double bestFitness = DBL_MAX; // Anfangswert der besten Fitnessfunktion
double bestX[N]; // Array von Parameterwerten entsprechend der besten Spur
for (int i = 0; i < N; i++) {
for (int j = 0; j < n; j++) {
x[j] = LB[j] + (UB[j] - LB[j]) * (double)rand() / RAND_MAX; // "Slugs" zufällig im angegebenen Parameterbereich platzieren
}
trail[i] = f(x); // Berechnung des Wertes der Fitnessfunktion für diese Parameter
if (trail[i] < bestFitness) { // wenn der Wert der Fitnessfunktion besser ist als der aktuelle beste Wert, wird er als neuer bester Wert gespeichert
bestFitness = trail[i];
for (int j = 0; j < n; j++) {
bestX[j] = x[j]; // Kopiere die Werte der gefundenen Parameter in das Array der besten Werte
}
bestTrail[i] = trail[i]; // kopiere den Funktionswert für die gefundenen Parameter in das Array der besten Funktionswerte
}
}
for (int iter = 0; iter < maxIter; iter++) { // Schleife über die Anzahl der Iterationen
for (int i = 0; i < N; i++) {
double r[n], d[n];
for (int j = 0; j < n; j++) {
r[j] = (double)rand() / RAND_MAX - 0,5; // Vektor für Zufallsinkremente
d[j] = r[j] * stepSize * (UB[j] - LB[j]); // Berechnung der Schrittweite
x[j] += d[j]; // Hinzufügen eines Schritts zu dem Parameter
if (x[j] < LB[j]) { // wenn der Parameter außerhalb des Bereichs liegt, ihn an der Grenze belassen
x[j] = LB[j];
} else if (x[j] > UB[j]) {
x[j] = UB[j];
}
}
double newTrail = f(x); // Berechnung des Funktionswertes für die neuen Parameter
if (newTrail <= trail[i]) { // wenn sich der Funktionswert verbessert oder nicht geändert hat, die neuen Parameter und den Funktionswert speichern
for (int j = 0; j < n; j++) {
bestX[j] = x[j]; // Kopieren der neuen Parameter in das Array der besten Parameterwerte
}
bestTrail[i] = newTrail; // kopiere den neuen Funktionswert in das Array der besten Funktionswerte
trail[i] = newTrail; // speichert den Funktionswert für die neuen Parameter in das Array der Funktionswerte für alle "Slugs"
if (bestTrail[i] < bestFitness) { // prüfen, ob die aktuelle beste Lösung besser ist als die aktuelle beste Lösung
bestFitness = bestTrail[i];
}
} else { // wenn sich die Funktionswerte verschlechtert haben, zurück zu den alten Parametern
for (int j = 0; j < n; j++) {
x[j] = bestX[j];
}
trail[i] = bestTrail[i];
}
}
for (int i = 0; i < N; i++) {
trail[i] *= (1.0 - k); // verdampft den Slug-Trail, um nicht im lokalen Maximum stecken zu bleiben
}
}
return bestFitness;
}
```
Wie Sie sehen können, verwenden wir einfach Schleifen, um Array-Werte Element für Element zu kopieren.
dieses Eisen weiß alles...))))
im allgemeinen Fall kann man wahrscheinlich darauf vertrauen, dass die Hardware den richtigen Algorithmus für die jeweilige Aufgabe auswählt, aber ich schaue lieber in meine Bewertungstabelle)))
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
Es wird notwendig sein, dies in ein Schema aufzuschlüsseln, wie alle Algos in den Artikeln gemacht werden.
Es wird notwendig sein, um es nach dem Schema zu brechen, wie alle Algos in den Artikeln getan werden. in dieser Form ist es nutzlos.
Versuchen Sie es über den Chat, ich frage mich, ob er eine solche Aufgabe bewältigen kann :) Mir sind die Token ausgegangen, also probiere ich es manchmal aus. Füttere ihn mit einem Beispielartikel und sorge dafür, dass er dem Stil folgt. Übrigens, ein tolles Startup für einen Penny ist so ein Bot in einem Warenkorb.
Leider, oder vielleicht auch zum Glück, generiert der Bot keine neuen informationen, und die öffentlich zugänglichen informationen sind oft verzerrt. ich denke, das liegt an den Mechanismen der informationsinterpolation. er lügt, erfindet nicht existierende abkürzungen von Algorithmen, erfindet sogar spontan autornamen und datum des erscheinens des Algorithmus))). man sollte mit solchen informationen sehr vorsichtig sein.
Als Assistent bei der Textbearbeitung, bei stilistischen Korrekturen und als Referenz beim Verfassen von Artikeln - ja, ein unverzichtbarer Assistent.