Discussione sull’articolo "Algoritmi di ottimizzazione della popolazione: Semina e Crescita degli Alberelli (Saplings Sowing and Growing up - SSG)" - pagina 12
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Sì, un organismo molto interessante.))
ma la lumaca usa solo 2 dimensioni, e anche gli AO più semplici sono in grado di gestire 2 dimensioni. Come si comporterà in 1000 dimensioni è un grosso problema, perché la complessità del problema cresce in modo non lineare con il numero di dimensioni.
L'algoritmo della muffa di melma è un metodo di ottimizzazione euristico basato sul comportamento delle muffe di melma. Questo algoritmo è stato sviluppato da Chiaro D'Ambrosio e appartiene al gruppo degli algoritmi di ottimizzazione "naturali".
L'essenza dell'algoritmo consiste nel posizionare una "lumaca" in un punto specifico e osservare come si diffonde intorno a quel punto, alla ricerca del massimo nutrimento. Nel corso di questo algoritmo, la lumaca lascia una traccia che evapora gradualmente. Più tracce rimangono in un'area, più è probabile che un'altra "lumaca" adotti quella traccia come percorso verso una maggiore concentrazione di cibo.
Nel contesto dell'ottimizzazione, questo comportamento da lumaca viene utilizzato per trovare soluzioni ottimali negli spazi dei parametri. Ad esempio, possiamo usare questo algoritmo per trovare il valore minimo di una funzione entro determinati limiti di parametro.
I vantaggi di questo algoritmo sono la sua semplicità e la sua capacità di convergere rapidamente a soluzioni ottimali in spazi multidimensionali. Tuttavia, può anche avere problemi a convergere verso la soluzione ottimale in problemi più complessi e non lineari.
L'algoritmo della formica è lo stesso, ma è generalizzato ai casi multidimensionali.
La convergenza della formica diminuisce con l'aumentare della dimensionalità, diminuisce rapidamente. tutti gli algoritmi si comportano allo stesso modo in generale. dipende dalla strategia di ricerca, e non conosciamo la strategia dello slug))).
la convergenza diminuisce più lentamente della crescita della complessità con l'aumentare della dimensionalità - considero la scalabilità di AO. la scalabilità dipende dal tipo di funzione, algoritmi diversi scalano in modo diverso su funzioni diverse.
L'algoritmo delle muffe di melma è un metodo di ottimizzazione euristico basato sul comportamento delle muffe di melma. Questo algoritmo è stato sviluppato da Chiaro D'Ambrosio e appartiene al gruppo degli algoritmi di ottimizzazione "naturali".
L'essenza dell'algoritmo consiste nel posizionare una "lumaca" in un punto specifico e osservare come si diffonde intorno a quel punto, alla ricerca del massimo nutrimento. Nel corso di questo algoritmo, la lumaca lascia una traccia che evapora gradualmente. Più tracce rimangono in un'area, più è probabile che un'altra "lumaca" adotti quella traccia come percorso verso una maggiore concentrazione di cibo.
Nel contesto dell'ottimizzazione, questo comportamento da lumaca viene utilizzato per trovare soluzioni ottimali negli spazi dei parametri. Ad esempio, si può usare questo algoritmo per trovare il valore minimo di una funzione entro determinati limiti di parametro.
I vantaggi di questo algoritmo sono la sua semplicità e la sua capacità di convergere rapidamente a soluzioni ottimali in spazi multidimensionali. Tuttavia, può anche avere problemi di convergenza alla soluzione ottimale in problemi più complessi e non lineari.
wow, che interessante. cercherò questo algoritmo, naturalmente è interessante smontarlo. e assemblare)))))))
wow, che interessante. cercherò questo algoritmo, naturalmente è interessante smontarlo. e assemblare))))))
Ecco un esempio di implementazione dell'algoritmo slug nel linguaggio di programmazione MQL:
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0,1; // coefficiente di evaporazione della traccia
const double stepSize = 0,001; // dimensione del passo di movimento del "lumacone"
double trail[N]; // array di tracce di ogni particella
double bestTrail[N]; // array della traccia migliore
double bestFitness = DBL_MAX; // valore iniziale della migliore funzione di fitness
double bestX[N]; // array di valori dei parametri corrispondenti alla traccia migliore
per (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; // posiziona "slugs" a caso nell'intervallo di parametri specificato
}
trail[i] = f(x); // calcola il valore della funzione di fitness per questi parametri
if (trail[i] < bestFitness) { // se il valore della funzione fitness è migliore del valore migliore attuale, memorizzarlo come nuovo valore migliore
bestFitness = trail[i];
memcpy(bestX, x, sizeof(bestX)); // copia i valori dei parametri trovati nell'array dei valori migliori
memcpy(bestTrail, trail, sizeof(bestTrail)); // copia dei valori delle funzioni per i parametri trovati nell'array dei valori delle funzioni migliori
}
}
for (int iter = 0; iter < maxIter; iter++) { // ciclo per numero di iterazioni
for (int i = 0; i < N; i++) {
double r[n], d[n];
per (int j = 0; j < n; j++) {
r[j] = (double)rand() / RAND_MAX - 0,5; // vettore di incremento casuale
d[j] = r[j] * stepSize * (UB[j] - LB[j]); // calcola l'ampiezza del passo
x[j] += d[j]; // aggiunge un passo al parametro
if (x[j] < LB[j]) { // se il parametro è fuori dall'intervallo, lasciarlo al limite
x[j] = LB[j];
} else if (x[j] > UB[j]) {
x[j] = UB[j];
}
}
double newTrail = f(x); // calcola il valore della funzione per i nuovi parametri
if (newTrail <= trail[i]) { // se il valore della funzione è migliorato o non è cambiato, salvare i nuovi parametri e il valore della funzione
memcpy(bestX, x, sizeof(bestX)); // copia i nuovi parametri nell'array dei valori dei parametri migliori
memcpy(bestTrail, &newTrail, sizeof(newTrail)); // copia il nuovo valore della funzione nell'array dei valori della funzione migliore
trail[i] = newTrail; // salvare il valore della funzione per i nuovi parametri nell'array dei valori della funzione per tutti gli "slug"
if (bestTrail[i] < bestFitness) { // verifica se la soluzione migliore attuale è migliore della soluzione migliore attuale
bestFitness = bestTrail[i];
}
} else { // se i valori della funzione sono peggiorati, tornare ai vecchi parametri
memcpy(x, bestX, sizeof(bestX));
trail[i] = bestTrail[i];
}
}
for (int i = 0; i < N; i++) {
trail[i] *= (1.0 - k); // evapora la scia di slug per evitare di rimanere bloccato nel massimo locale
}
}
return bestFitness;
}
```
Questo codice utilizza valori casuali dei parametri selezionati come punto di partenza, quindi elabora ogni particella in modo sequenziale. Per ogni particella, genera un vettore di incremento casuale, calcola la dimensione del passo e la aggiunge a ogni parametro. Calcola quindi il valore della funzione per i nuovi parametri e lo memorizza se il valore diminuisce o rimane invariato. Alla fine di ogni ciclo, evapora la traccia di slug per evitare di rimanere bloccati su un massimo locale.
Probabilmente dovrete modificarlo in questo punto 😀 gpt issued
È corretto, non esiste una funzione `memcpy` in MQL. Per copiare i valori da una variabile all'altra, è possibile utilizzare l'operatore di assegnazione `=`. Ecco un esempio di codice modificato senza utilizzare la funzione `memcpy`:
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0,1; // coefficiente di evaporazione della traccia
const double stepSize = 0,001; // la dimensione del passo di movimento del "lumacone"
double trail[N]; // array di tracce di ogni particella
double bestTrail[N]; // array della traccia migliore
double bestFitness = DBL_MAX; // valore iniziale della migliore funzione di fitness
double bestX[N]; // array di valori dei parametri corrispondenti alla traccia migliore
per (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; // posiziona "slugs" a caso nell'intervallo di parametri specificato
}
trail[i] = f(x); // calcola il valore della funzione di fitness per questi parametri
if (trail[i] < bestFitness) { // se il valore della funzione fitness è migliore del valore migliore attuale, memorizzarlo come nuovo valore migliore
bestFitness = trail[i];
per (int j = 0; j < n; j++) {
bestX[j] = x[j]; // copia i valori dei parametri trovati nell'array dei valori migliori
}
bestTrail[i] = trail[i]; // copia il valore della funzione per i parametri trovati nell'array dei valori della funzione migliore
}
}
for (int iter = 0; iter < maxIter; iter++) { // ciclo attraverso il numero di iterazioni
per (int i = 0; i < N; i++) {
double r[n], d[n];
per (int j = 0; j < n; j++) {
r[j] = (double)rand() / RAND_MAX - 0,5; // vettore di incremento casuale
d[j] = r[j] * stepSize * (UB[j] - LB[j]); // calcola l'ampiezza del passo
x[j] += d[j]; // aggiunge un passo al parametro
if (x[j] < LB[j]) { // se il parametro è fuori dall'intervallo, lasciarlo al limite
x[j] = LB[j];
} else if (x[j] > UB[j]) {
x[j] = UB[j];
}
}
double newTrail = f(x); // calcola il valore della funzione per i nuovi parametri
if (newTrail <= trail[i]) { // se il valore della funzione è migliorato o non è cambiato, salvare i nuovi parametri e il valore della funzione
for (int j = 0; j < n; j++) {
bestX[j] = x[j]; // copia i nuovi parametri nell'array dei valori dei parametri migliori
}
bestTrail[i] = newTrail; // copia il nuovo valore della funzione nell'array dei valori della funzione migliore
trail[i] = newTrail; // memorizza il valore della funzione per i nuovi parametri nell'array dei valori della funzione per tutti gli "slug"
if (bestTrail[i] < bestFitness) { // verifica se la soluzione migliore attuale è migliore della soluzione migliore attuale
bestFitness = bestTrail[i];
}
} else { // se i valori della funzione sono peggiorati, tornare ai vecchi parametri
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); // vaporizza la scia di slug per evitare di rimanere bloccato nel massimo locale
}
}
return bestFitness;
}
```
Come si può vedere, stiamo semplicemente usando i loop per copiare i valori degli array elemento per elemento.
questo ferro sa tutto...))))
in generale, probabilmente, ci si può fidare dell'hardware per scegliere l'algoritmo più adatto al compito, ma preferisco guardare nella mia tabella di valutazione)))
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
Sarà necessario scomporlo in uno schema, come fanno tutti gli algoritmi degli articoli.
Sarà necessario suddividerlo in base allo schema, come sono fatti tutti gli algoritmi negli articoli. in questa forma è inutile.
Provatelo via chat, mi chiedo se riuscirà a gestire un compito del genere :) Ho finito i gettoni, quindi ogni tanto mi diletto. Dategli in pasto un articolo di esempio e fategli seguire lo stile. A proposito, una grande startup per un centesimo è un bot di questo tipo in un carrello.
Purtroppo, o forse per fortuna, il bot non genera nuove informazioni e quelle disponibili al pubblico sono spesso distorte. Credo che ciò sia dovuto ai meccanismi di interpolazione delle informazioni. Mente, inventa abbreviazioni inesistenti di algoritmi, inventa al volo persino i nomi degli autori e le date di apparizione dell'algoritmo)).
Come assistente nell'editing del testo, nelle correzioni stilistiche e come riferimento durante la stesura degli articoli - sì, un assistente indispensabile.