Discussion de l'article "Algorithmes d'optimisation de la population : Semis et Croissance des Jeunes Arbres, ou Saplings Sowing and Growing up en anglais (SSG)" - page 12
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Oui, un organisme très intéressant.))
Mais la limace n'utilise que 2 dimensions, et même les OA les plus simples peuvent faire face à 2 dimensions. Comment se comportera-t-elle dans 1000 dimensions est une grande question, parce que la complexité du problème croît de manière non linéaire avec le nombre de dimensions.
L'algorithme de la moisissure visqueuse est une méthode d'optimisation heuristique basée sur le comportement des moisissures visqueuses. Cet algorithme a été développé par Chiaro D'Ambrosio et appartient au groupe des algorithmes d'optimisation "naturels".
L'essence de l'algorithme consiste à placer une "limace" en un point spécifique et à observer comment elle se répand autour de ce point, à la recherche d'un maximum de nourriture. Au cours de cet algorithme, la limace laisse derrière elle une trace qui s'évapore progressivement. Plus il y a de traces dans une zone, plus il y a de chances qu'une autre "limace" adopte cette trace comme chemin vers une plus grande concentration de nourriture.
Dans le contexte de l'optimisation, ce comportement des limaces est utilisé pour trouver des solutions optimales dans des espaces de paramètres. Par exemple, nous pouvons utiliser cet algorithme pour trouver la valeur minimale d'une fonction dans des limites de paramètres données.
Les avantages de cet algorithme sont sa simplicité et sa capacité à converger rapidement vers des solutions optimales dans des espaces multidimensionnels. Cependant, il peut aussi avoir des problèmes pour converger vers la solution optimale dans des problèmes plus complexes et non linéaires.
L'algorithme de la fourmi est le même, mais il est généralisé aux cas multidimensionnels.
La convergence de la fourmi diminue avec l'augmentation de la dimensionnalité, elle diminue rapidement. tous les algorithmes se comportent de la même manière en général. cela dépend de la stratégie de recherche, et nous ne connaissons pas la stratégie de la limace))).
La convergence diminue plus lentement que la croissance de la complexité avec l'augmentation de la dimensionnalité - je considère qu'il s'agit d'une évolutivité AO. L'évolutivité dépend du type de fonction, différents algorithmes s'adaptent différemment à différentes fonctions.
L'algorithme de la moisissure visqueuse est une méthode d'optimisation heuristique basée sur le comportement des moisissures visqueuses. Cet algorithme a été développé par Chiaro D'Ambrosio et appartient au groupe des algorithmes d'optimisation "naturels".
L'essence de l'algorithme consiste à placer une "limace" en un point spécifique et à observer comment elle se répand autour de ce point, à la recherche d'un maximum de nourriture. Au cours de cet algorithme, la limace laisse derrière elle une trace qui s'évapore progressivement. Plus il y a de traces dans une zone, plus il y a de chances qu'une autre "limace" adopte cette trace comme chemin vers une plus grande concentration de nourriture.
Dans le contexte de l'optimisation, ce comportement des limaces est utilisé pour trouver des solutions optimales dans des espaces de paramètres. Par exemple, nous pouvons utiliser cet algorithme pour trouver la valeur minimale d'une fonction dans des limites de paramètres données.
Les avantages de cet algorithme sont sa simplicité et sa capacité à converger rapidement vers des solutions optimales dans des espaces multidimensionnels. Cependant, il peut aussi avoir des problèmes pour converger vers la solution optimale dans des problèmes plus complexes et non linéaires.
wow, comme c'est intéressant. je vais chercher cet algo, bien sûr il est intéressant de le démonter. et de l'assembler)))))))
wow, comme c'est intéressant. je vais chercher cet algo, bien sûr il est intéressant de le démonter. et de l'assembler))))))
Voici un exemple d'implémentation de l'algorithme slug dans le langage de programmation MQL :
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0.1 ; // coefficient d'évaporation de la trace
const double stepSize = 0.001 ; // taille du pas de déplacement de la "limace
double trail[N] ; // tableau des traces de chaque particule
double bestTrail[N] ; // tableau de la meilleure trace
double bestFitness = DBL_MAX ; // valeur initiale de la meilleure fonction de fitness
double bestX[N] ; // tableau des valeurs des paramètres correspondant à la meilleure trace
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 ; // placer des "slugs" de manière aléatoire dans la plage de paramètres spécifiée
}
trail[i] = f(x) ; // calculer la valeur de la fonction d'aptitude pour ces paramètres
if (trail[i] < bestFitness) { // si la valeur de la fonction d'aptitude est meilleure que la meilleure valeur actuelle, la stocker comme nouvelle meilleure valeur
bestFitness = trail[i] ;
memcpy(bestX, x, sizeof(bestX)) ; // copie les valeurs des paramètres trouvés dans le tableau des meilleures valeurs
memcpy(bestTrail, trail, sizeof(bestTrail)) ; // copie les valeurs des fonctions pour les paramètres trouvés dans le tableau des meilleures valeurs des fonctions
}
}
for (int iter = 0 ; iter < maxIter ; iter++) { // boucle par le nombre d'itérations
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 ; // vecteur d'incrémentation aléatoire
d[j] = r[j] * stepSize * (UB[j] - LB[j]) ; // calcul de la largeur du pas
x[j] += d[j] ; // ajoute un pas au paramètre
if (x[j] < LB[j]) { // si le paramètre est hors de portée, le laisser à la limite
x[j] = LB[j] ;
} else if (x[j] > UB[j]) {
x[j] = UB[j] ;
}
}
double newTrail = f(x) ; // calculer la valeur de la fonction pour les nouveaux paramètres
if (newTrail <= trail[i]) { // si la valeur de la fonction s'est améliorée ou n'a pas changé, enregistrer les nouveaux paramètres et la valeur de la fonction
memcpy(bestX, x, sizeof(bestX)) ; // copie les nouveaux paramètres dans le tableau des meilleures valeurs de paramètres
memcpy(bestTrail, &newTrail, sizeof(newTrail)) ; // copie la nouvelle valeur de la fonction dans le tableau des meilleures valeurs de la fonction
trail[i] = newTrail ; // enregistrer la valeur de la fonction pour les nouveaux paramètres dans le tableau des valeurs de la fonction pour tous les "slugs" (bouchons)
if (bestTrail[i] < bestFitness) { // vérifier si la meilleure solution actuelle est meilleure que la meilleure solution actuelle
bestFitness = bestTrail[i] ;
}
} else { // si les valeurs de la fonction se sont détériorées, revenir aux anciens paramètres
memcpy(x, bestX, sizeof(bestX)) ;
trail[i] = bestTrail[i] ;
}
}
for (int i = 0 ; i < N ; i++) {
trail[i] *= (1.0 - k) ; // évaporation de la trace du limaçon pour éviter de rester coincé dans le maximum local
}
}
return bestFitness ;
}
```
Ce code utilise des valeurs aléatoires des paramètres sélectionnés comme point de départ, puis traite chaque particule de manière séquentielle. Pour chaque particule, il génère un vecteur d'incrémentation aléatoire, calcule la taille du pas et l'ajoute à chaque paramètre. Il calcule ensuite la valeur de la fonction pour les nouveaux paramètres et l'enregistre si la valeur diminue ou reste la même. À la fin de chaque cycle, il évapore la trace du limaçon pour éviter de rester bloqué à un maximum local.
Il faudra sans doute y apporter des modifications 😀 gpt émis
Vous avez raison, il n'y a pas de fonction `memcpy` dans MQL. Pour copier des valeurs d'une variable à une autre, vous pouvez utiliser l'opérateur d'affectation `=`. Voici un exemple du code modifié sans utiliser la fonction `memcpy` :
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0.1 ; // coefficient d'évaporation de la trace
const double stepSize = 0.001 ; // la taille du pas de déplacement de la "limace
double trail[N] ; // tableau des traces de chaque particule
double bestTrail[N] ; // tableau de la meilleure trace
double bestFitness = DBL_MAX ; // valeur initiale de la meilleure fonction de fitness
double bestX[N] ; // tableau des valeurs des paramètres correspondant à la meilleure trace
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 ; // placer des "slugs" de manière aléatoire dans la plage de paramètres spécifiée
}
trail[i] = f(x) ; // calculer la valeur de la fonction d'aptitude pour ces paramètres
if (trail[i] < bestFitness) { // si la valeur de la fonction d'aptitude est meilleure que la meilleure valeur actuelle, la stocker comme nouvelle meilleure valeur
bestFitness = trail[i] ;
for (int j = 0 ; j < n ; j++) {
bestX[j] = x[j] ; // copie les valeurs des paramètres trouvés dans le tableau des meilleures valeurs
}
bestTrail[i] = trail[i] ; // copie la valeur de la fonction pour les paramètres trouvés dans le tableau des meilleures valeurs de la fonction
}
}
for (int iter = 0 ; iter < maxIter ; iter++) { // boucle sur le nombre d'itérations
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 ; // vecteur d'incrémentation aléatoire
d[j] = r[j] * stepSize * (UB[j] - LB[j]) ; // calcul de la largeur du pas
x[j] += d[j] ; // ajoute un pas au paramètre
if (x[j] < LB[j]) { // si le paramètre est hors de portée, le laisser à la limite
x[j] = LB[j] ;
} else if (x[j] > UB[j]) {
x[j] = UB[j] ;
}
}
double newTrail = f(x) ; // calculer la valeur de la fonction pour les nouveaux paramètres
if (newTrail <= trail[i]) { // si la valeur de la fonction s'est améliorée ou n'a pas changé, enregistrer les nouveaux paramètres et la valeur de la fonction
for (int j = 0 ; j < n ; j++) {
bestX[j] = x[j] ; // copie les nouveaux paramètres dans le tableau des meilleures valeurs de paramètres
}
bestTrail[i] = newTrail ; // copie la nouvelle valeur de la fonction dans le tableau des meilleures valeurs de la fonction
trail[i] = newTrail ; // stocker la valeur de la fonction pour les nouveaux paramètres dans le tableau des valeurs de la fonction pour tous les "slugs" (bouchons)
if (bestTrail[i] < bestFitness) { // vérifier si la meilleure solution actuelle est meilleure que la meilleure solution actuelle
bestFitness = bestTrail[i] ;
}
} else { // si les valeurs de la fonction se sont détériorées, revenir aux anciens paramètres
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) ; // vaporise la trace du limaçon pour éviter de rester coincé dans le maximum local
}
}
return bestFitness ;
}
```
Comme vous pouvez le voir, nous utilisons simplement des boucles pour copier les valeurs d'un tableau élément par élément.
ce matériel sait tout...))))
dans le cas général, on peut probablement faire confiance au matériel pour choisir l'algo adapté à la tâche, mais je préfère regarder dans mon tableau d'évaluation)))
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
Il sera nécessaire de le décomposer en un schéma, comme le font tous les algorithmes dans les articles.
Il faudra le décomposer selon le schéma, comme le font tous les algos dans les articles. sous cette forme, il est inutile.
Essayez-le via le chat, je me demande s'il peut gérer une telle tâche :) Je n'ai plus de tokens, alors je m'amuse parfois. Donnez-lui un exemple d'article et faites en sorte qu'il suive le style. D'ailleurs, une startup géniale pour un penny est un tel bot dans un panier.
Malheureusement, ou peut-être heureusement, le bot ne génère pas de nouvelles informations, et les informations disponibles publiquement sont souvent déformées. je pense que cela est dû aux mécanismes d'interpolation des informations. il ment, invente des abréviations d'algorithmes inexistantes, invente même des noms d'auteurs à la volée et des dates d'apparition de l'algorithme))). vous devriez être très prudent avec de telles informations.
En tant qu'assistant pour l'édition de textes, les corrections stylistiques et les références lors de la rédaction d'articles - oui, un assistant indispensable.