Algorithmes d'optimisation de la population : Algorithme d'Optimisation du Loup Gris - Grey Wolf Optimizer (GWO)

MetaTrader 5 — Exemples | 2 octobre 2023, 10:43

684

Andrey Dik

Sommaire

1. Introduction
2. Description de l'algorithme
3. Fonctions de tests
4. Résultats des tests

1. Introduction

L'algorithme du Loup Gris est un algorithme d'intelligence d'essaim méta-heuristique stochastique développé en 2014. Son idée est basée sur le modèle de chasse en meute des loups gris. Il existe 4 types de loups : alpha, bêta, delta et oméga. L’Alpha a le plus de "poids" dans la prise de décision et dans la gestion de la meute. Viennent ensuite le Bêta et le Delta, qui obéissent à l'Alpha et ont le pouvoir sur le reste des loups. Le loup Oméga obéit toujours au reste des loups dominants.

Dans le modèle mathématique de la hiérarchie des loups, le loup alpha-α est considéré comme le loup dominant de la meute et ses ordres doivent être exécutés par les membres de la meute. Les loups bêta-β-subordonnés assistent l'alpha dans la prise de décision et sont considérés comme les meilleurs candidats pour le rôle d'alpha. Les loups delta δ doivent obéir à alpha et bêta, mais ils dominent oméga. Les loups Omega ω sont considérés comme les boucs émissaires de la meute et les individus les moins importants. Ils ne sont autorisés à manger qu'à la fin. L’Alpha est considéré comme la solution la plus favorable.

Les deuxième et troisième meilleures solutions sont respectivement bêta et delta. Le reste des solutions est considéré comme oméga. On suppose que les loups les plus aptes (alpha, bêta et delta), c'est-à-dire les plus proches de la proie, seront approchés par le reste des loups. Après chaque approche, il est déterminé qui est alpha, bêta et delta à ce stade, puis les loups sont à nouveau réarrangés. La formation se déroule jusqu'à ce que les loups se rassemblent en meute, ce qui sera la direction optimale pour une attaque avec une distance minimale.

Au cours de l'algorithme, 3 étapes principales sont effectuées au cours desquelles les loups recherchent une proie, l'entourent et l'attaquent. La recherche révèle alpha, bêta et delta - les loups les plus proches de la proie. Les autres, obéissant aux dominants, peuvent commencer à entourer la proie ou continuer à se déplacer au hasard à la recherche de la meilleure option.

2. Description de l'algorithme

La hiérarchie dans la meute est représentée schématiquement dans la figure 1. Alpha joue un rôle dominant.

dominance

Fig. 1 : Hiérarchie sociale dans une meute de loups

Modèle mathématique et algorithme
Hiérarchie sociale:

La meilleure solution sous la forme d'un loup alpha (α).
La deuxième meilleure solution en tant que loup bêta (β).
La troisième meilleure solution en tant que loup delta (δ).
Les autres solutions possibles comme oméga vole (ω).

Encerclement des proies : lorsqu'il existe déjà les meilleures solutions alpha, bêta et delta, les actions ultérieures dépendent de l'oméga.

étapes

Fig. 2 : Etapes de la chasse : recherche, encerclement, attaque.

Toutes les itérations de l'algorithme sont représentées par ces 3 étapes : recherche, encerclement et chasse. La version canonique de l'algorithme présente le ratio calculé a introduit pour améliorer la convergence de l'algorithme. Ce ratio diminue jusqu'à 0 à chaque itération. L'initialisation des loups est en cours tant que le ratio dépasse 1. A ce stade, la position de la proie est totalement inconnue, les loups doivent donc être répartis au hasard.

Après l'étape de "recherche", la valeur de la fonction de fitness est déterminée, et seulement après cela, il est possible de passer à l'étape "d'encerclement". A ce stade, le ratio a est supérieur à 1. Cela signifie que alpha, beta et delta s'éloignent de leurs positions précédentes, permettant ainsi d'affiner la position de la proie estimée. Lorsque le rapport а devient égal à 1, l'étape "d'attaque" démarre, et le ratio tend vers 0 avant la fin des itérations. Cela amène les loups à s'approcher de la proie, suggérant que la meilleure position a déjà été trouvée. Mais si à ce stade l'un des loups trouve une meilleure solution, alors la position de la proie et la hiérarchie des loups seront mises à jour. Mais le ratio tendra toujours vers 0. Le processus de modification de a est représenté par une fonction non linéaire. Les étapes sont schématisées sur la figure 2.

Le comportement des loups oméga est inchangé à toutes les itérations et consiste à suivre le centre géométrique entre les positions des individus actuellement dominants. Dans la figure 3, alpha, bêta et delta s'écartent de leur position précédente dans une direction aléatoire avec un rayon donné par les coefficients. Et les omégas se déplacent vers le centre entre eux, mais avec un certain degré de probabilité de s'en écarter dans le rayon. Les rayons déterminent le ratio а , qui, comme on s'en souvient, change, entraînant une diminution proportionnelle des rayons.

encerclement

Fig. 3 : Schéma du mouvement oméga par rapport à alpha, beta et delta

Le pseudo-code de l'algorithme GWO est le suivant :

1) Initialisation aléatoire de la population de loups gris.
2) Calcul du fitness de chaque membre de la population.
3) Chefs de meute :
-α = membre avec la meilleure valeur de fitness
-β = deuxième meilleur membre (en termes de fitness)
-δ = troisième meilleur membre (en termes de valeur de fitness)
Mise à jour de la position de tous les loups oméga selon les équations dépendant de α, β, δ
4) Calcul du fitness de chaque membre de la population.
5) répétition de l'étape 3.

Passons au code de l'algorithme. Le seul ajout que j'ai apporté à la version originale est la possibilité de définir le nombre de loups de tête dans la meute. Vous pouvez maintenant définir n'importe quel nombre de leaders, jusqu'à la meute entière. Cela peut être utile pour des tâches spécifiques.

Nous commençons, comme d'habitude, par l'unité élémentaire de l'algorithme : le loup, qui est une solution au problème. Il s'agit d'une structure qui comprend un tableau de coordonnées et une valeur de proie (fonctions de fitness). La structure est la même pour les leaders et pour les membres mineurs de la meute. Cela simplifie l'algorithme et nous permet d'utiliser les mêmes structures dans les boucles. Au cours de toutes les itérations, les rôles des loups peuvent changer plusieurs fois. Les rôles sont uniquement déterminés par la position dans le tableau après le tri. Les leaders sont au début du tableau.

//——————————————————————————————————————————————————————————————————————————————
struct S_Wolf
{
  double c []; //coordinates
  double p;    //prey
};
//——————————————————————————————————————————————————————————————————————————————

La meute de loups est représentée par une classe compacte et compréhensible. Nous déclarons ici les plages et le pas des paramètres à optimiser, la meilleure position de production, la meilleure valeur de solution et les fonctions auxiliaires :

//——————————————————————————————————————————————————————————————————————————————
class C_AO_GWO //wolfpack
{
  //============================================================================
  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //manimum search range
  public: double rangeStep []; //step search
  public: S_Wolf wolves    []; //wolves of the pack
  public: double cB        []; //best prey coordinates
  public: double pB;           //best prey

  public: void InitPack (const int    coordinatesP,   //number of opt. parameters
                         const int    wolvesNumberP,  //wolves number
                         const int    alphaNumberP,   //alpha beta delta number
                         const int    epochCountP);   //epochs number

  public: void TasksForWolves      (int epochNow);
  public: void RevisionAlphaStatus ();


  //============================================================================
  private: void   ReturnToRange (S_Wolf &wolf);
  private: void   SortingWolves ();
  private: double SeInDiSp      (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI     (double Min, double Max);

  private: int    coordinates;     //coordinates number
  private: int    wolvesNumber;    //the number of all wolves
  private: int    alphaNumber;     //Alpha beta delta number of all wolves
  private: int    epochCount;

  private: S_Wolf wolvesT    [];   //temporary, for sorting
  private: int    ind        [];   //array for indexes when sorting
  private: double val        [];   //array for sorting

  private: bool   searching;       //searching flag
};
//——————————————————————————————————————————————————————————————————————————————

Traditionnellement, la déclaration d’une classe est suivie de son initialisation. Ici, nous réinitialisons la valeur minimale de type "double" de la condition physique des loups et nous distribuons la taille des tableaux :

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO::InitPack (const int    coordinatesP,   //number of opt. parameters
                         const int    wolvesNumberP,  //wolves number
                         const int    alphaNumberP,   //alpha beta delta number
                         const int    epochCountP)    //epochs number
{
  MathSrand (GetTickCount ());
  searching = false;
  pB        = -DBL_MAX;

  coordinates  = coordinatesP;
  wolvesNumber = wolvesNumberP;
  alphaNumber  = alphaNumberP;
  epochCount   = epochCountP;

  ArrayResize (rangeMax,  coordinates);
  ArrayResize (rangeMin,  coordinates);
  ArrayResize (rangeStep, coordinates);
  ArrayResize (cB,        coordinates);

  ArrayResize (ind, wolvesNumber);
  ArrayResize (val, wolvesNumber);

  ArrayResize (wolves,  wolvesNumber);
  ArrayResize (wolvesT, wolvesNumber);

  for (int i = 0; i < wolvesNumber; i++)
  {
    ArrayResize (wolves  [i].c, coordinates);
    ArrayResize (wolvesT [i].c, coordinates);
    wolves  [i].p = -DBL_MAX;
    wolvesT [i].p = -DBL_MAX;
  }
}
//——————————————————————————————————————————————————————————————————————————————

La première méthode publique appelée à chaque itération est la plus volumineuse et la plus difficile à comprendre. Voici la logique principale de l'algorithme. La performance de l'algorithme est assurée par un mécanisme probabiliste strictement décrit par des équations. Considérons cette méthode étape par étape. A la 1ère itération, lorsque la position de la proie visée est inconnue, après vérification du drapeau, nous envoyons les loups dans une direction aléatoire simplement en générant des valeurs à partir du min et du max des paramètres optimisés :

//----------------------------------------------------------------------------
//space has not been explored yet, then send the wolf in a random direction
if (!searching)
{
  for (int w = 0; w < wolvesNumber; w++)
  {
    for (int c = 0; c < coordinates; c++)
    {
      wolves [w].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
      wolves [w].c [c] = SeInDiSp  (wolves [w].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }
   
  searching = true;
  return;
}

Dans la version canonique de la description de l'algorithme, il existe des équations qui opèrent des vecteurs. Mais elles sont beaucoup plus clairs sous forme de code. Le calcul des loups oméga est effectué avant le calcul des loups alpha, bêta et delta car nous devons utiliser les valeurs précédentes des leaders.

Le composant principal qui fournit 3 étapes de chasse (recherche, encerclement et attaque) est le ratio a. Il représente une dépendance non linéaire de l'itération courante et du nombre total d'itérations, et tend vers 0.
Les composantes suivantes de l'équation sont Ai et Сi :

Ai = 2,0 * a * r1 - a
Ci = 2,0 * r2

avec r1 et r2, des nombres aléatoires dans la plage [0.0 ; 1.0].
Dans l'expression

Xn += loups [abd].c [c] - Ai * (Ci * loups [abd].c [c] - loups [w].c [c]);

les coordonnées des loups sont ajustées en fonction des valeurs moyennes des loups leaders. Étant donné que n'importe quel nombre de lignes de repère peut être spécifié dans l'algorithme, la somme des coordonnées est effectuée en boucle. Après cela, le montant obtenu est divisé par le nombre de leaders. Nous effectuons cette opération pour chaque coordonnée séparément, en générant à chaque fois de nouvelles valeurs r1 et r2. Comme nous pouvons le voir, la nouvelle position des loups oméga est ajustée en fonction des positions des leaders en tenant compte de leur propre position actuelle.

//----------------------------------------------------------------------------
double a  = sqrt (2.0 * (1.0 - (epochNow / epochCount)));
double r1 = 0.0;
double r2 = 0.0;

double Ai = 0.0;
double Ci = 0.0;
double Xn = 0.0;

double min = 0.0;
double max = 1.0;

//omega-----------------------------------------------------------------------
for (int w = alphaNumber; w < wolvesNumber; w++)
{
  Xn = 0.0;

  for (int c = 0; c < coordinates; c++)
  {
    for (int abd = 0; abd < alphaNumber; abd++)
    {
      r1 = RNDfromCI (min, max);
      r2 = RNDfromCI (min, max);
      Ai = 2.0 * a * r1 - a;
      Ci = 2.0 * r2;
      Xn += wolves [abd].c [c] - Ai * (Ci * wolves [abd].c [c] - wolves [w].c [c]);
    }

    wolves [w].c [c] = Xn /= (double)alphaNumber;
  }

  ReturnToRange (wolves [w]);
}

Voici le calcul des leaders. Les ratios a, Ai et Ci pour chaque coordonnée sont calculés pour chacun d’eux. La seule différence est que la position des leaders change par rapport aux meilleures coordonnées des proies du moment et à leurs propres positions. Les leaders tournent autour de la proie, entrent et sortent, et contrôlent les loups mineurs lors de l'attaque.

//alpha, beta, delta----------------------------------------------------------
for (int w = 0; w < alphaNumber; w++)
{
  for (int c = 0; c < coordinates; c++)
  {
    r1 = RNDfromCI (min, max);
    r2 = RNDfromCI (min, max);

    Ai = 2.0 * a * r1 - a;
    Ci = 2.0 * r2;

    wolves [w].c [c] = cB [c] - Ai * (Ci * cB [c] - wolves [w].c [c]);
  }

  ReturnToRange (wolves [w]);
}

Il s'agit de la 2ème méthode publique appelée à chaque itération. Le statut des leaders de la meute est mis à jour ici. En fait, les loups sont triés par leur valeur de fitness. Si de meilleures coordonnées de proies que celles stockées dans l'ensemble de la meute sont trouvées, nous mettons à jour les valeurs.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO::RevisionAlphaStatus ()
{
  SortingWolves ();

  if (wolves [0].p > pB)
  {
    pB = wolves [0].p;
    ArrayCopy (cB, wolves [0].c, 0, 0, WHOLE_ARRAY);
  }
}
//——————————————————————————————————————————————————————————————————————————————

3. Fonctions de tests

Vous connaissez déjà les fonctions Skin, Forest et Megacity. Ces fonctions de test satisfont tous les critères de complexité pour tester les algorithmes d'optimisation. Mais il y a une caractéristique qui n'a pas été prise en compte. Elle devrait être mise en œuvre pour augmenter l'objectivité du test. Les exigences sont les suivantes :

L'extremum global ne doit pas se situer aux frontières de l’intervalle. Si l'algorithme n'a pas de contrôle sur le respect de l’intervalle, des situations sont possibles lorsque l'algorithme affichera d'excellents résultats. Cela est dû au fait que les valeurs seront situées sur les bordures à cause d'un défaut interne.
L'extremum global ne doit pas être au centre des coordonnées de la plage. Dans ce cas, l'algorithme, générant des valeurs moyennées dans une plage, est pris en compte.
Le minimum global doit être situé au centre des coordonnées. Cela est nécessaire pour exclure délibérément les situations décrites dans la p. 2.
Le calcul des résultats de la fonction de test doit prendre en compte le cas où des nombres générés aléatoirement sur tout le domaine de la fonction (lorsque la fonction est multi-variables) donneront un résultat moyen d'environ 50% du maximum, bien qu'en fait ces résultats aient été obtenus par hasard.

Compte tenu de ces exigences, les limites des fonctions de test ont été révisées et les centres de la plage ont été déplacés vers les minimums des valeurs de fonction. Permettez-moi de résumer une fois de plus. Cela était nécessaire pour obtenir la plus grande plausibilité et objectivité des résultats des algorithmes d'optimisation des tests. Ainsi, sur de nouvelles fonctions de test, l'algorithme d'optimisation basé sur la génération de nombres aléatoires a montré un résultat global naturellement faible. Le tableau d'évaluation mis à jour se trouve à la fin de l'article.

Fonction Skin. Une fonction lisse qui a plusieurs extrema locaux qui peuvent confondre l'algorithme d'optimisation car il peut rester coincé dans l'un d'eux. Le seul extremum global est caractérisé par des valeurs faiblement changeantes dans le voisinage. Cette fonction montre clairement la capacité de l'algorithme à être divisé en domaines d'étude, plutôt que de se concentrer sur un seul. L'algorithme de colonie d'abeilles (ABC) se comporte en particulier de cette façon.

Skin

Fig. 4 : Fonction de test Skin

Fonction Forest. Une fonction avec plusieurs extrêmes lisses et plusieurs extrêmes non différentiables. Il s'agit d'un test digne des algorithmes d'optimisation pour trouver une "aiguille dans une botte de foin". Trouver un seul point maximum global est une tâche très difficile, surtout si la fonction contient de nombreuses variables. L'algorithme de colonie de fourmis (ACO) s'est distingué dans cette tâche par le comportement caractéristique, qui ouvre des chemins vers l'objectif d'une manière incroyable.

Forest

Fig. 5 : Fonction de test Forest

Fonction Megacity. La fonction est un problème d'optimisation discret avec un extrema global et plusieurs extrema locaux. La surface extrêmement complexe à étudier fournit un bon test des algorithmes qui nécessitent un gradient. Une complexité supplémentaire est ajoutée par un "plancher" complètement pair, qui est aussi un minimum, qui ne donne aucune information sur la direction possible vers le maximum global.

Megacity

Fig. 6 : Fonction de test Megacity

Des vérifications des arguments entrants pour les valeurs hors plage ont été ajoutées au code des fonctions de test. Dans les versions précédentes des fonctions, les algorithmes d'optimisation pouvaient injustement obtenir des valeurs de fonction supérieures à ce que la fonction a réellement dans la plage de sa définition.

4. Résultats des tests

En raison des modifications apportées aux fonctions de test, le banc d'essai a également été mis à jour. Sur le côté droit de l'écran, vous pouvez toujours voir les graphiques de convergence des algorithmes d'optimisation. La ligne verte représente les résultats de convergence sur les fonctions à 2 variables. La ligne bleue représente les fonctions à 40 variables. Le rouge indique des fonctions avec 1000 variables. Le plus grand cercle noir indique la position du maximum global de la fonction. Le petit cercle noir indique la position de la valeur actuelle de la solution de l'algorithme d'optimisation. Le réticule de lignes blanches indique le centre géométrique des fonctions de test et correspond au minimum global. Ceci a été introduit pour une meilleure perception visuelle du comportement des algorithmes testés. Les points blancs indiquent des solutions intermédiaires moyennes. Les petits points colorés indiquent les paires de coordonnées de la dimension correspondante. La couleur indique la position ordinale de la dimension de la fonction de test.

Les résultats mis à jour des tests des algorithmes d'optimisation discutés dans les articles précédents peuvent être consultés dans le tableau mis à jour. Pour plus de clarté visuelle, la ligne sur la vitesse de convergence a été supprimée du tableau - elle peut être déterminée visuellement avec l'animation. Ajout de la colonne de description de l'algorithme.

Résultats du test ACOm (Ant Colony Optimization) :

2022.11.28 12:17:00.468 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:17:06.382 Test_AO_ACO (EURUSD,M1) 1 Skin ; Func exécute 10000 résultats : 4,844203223078298
2022.11.28 12:17:06.382 Test_AO_ACO (EURUSD,M1) 0,98229
2022.11.28 12:17:14.191 Test_AO_ACO (EURUSD,M1) 20 Skin ; Func exécute 10000 résultats : 4,043383610736287
2022.11.28 12:17:14.191 Test_AO_ACO (EURUSD,M1) 0,79108
2022.11.28 12:17:55.578 Test_AO_ACO (EURUSD,M1) 500 Skin ; Func exécute 10000 résultats : 1,2580170651681026
2022.11.28 12:17:55.578 Test_AO_ACO (EURUSD,M1) 0,12602
2022.11.28 12:17:55.578 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:18:01.491 Test_AO_ACO (EURUSD,M1) 1 Forest ; Func exécute 10000 résultats : 1,7678766100234538
2022.11.28 12:18:01.491 Test_AO_ACO (EURUSD,M1) 1,00000
2022.11.28 12:18:09.508 Test_AO_ACO (EURUSD,M1) 20 Forest ; Func exécute 10000 résultats : 1,0974381500585855
2022.11.28 12:18:09.508 Test_AO_ACO (EURUSD,M1) 0,62077
2022.11.28 12:18:53.348 Test_AO_ACO (EURUSD,M1) 500 Forest ; Func exécute 10000 résultats : 0,20367726028454042
2022.11.28 12:18:53.348 Test_AO_ACO (EURUSD,M1) 0,11521
2022.11.28 12:18:53.348 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:18:59.303 Test_AO_ACO (EURUSD,M1) 1 Megacity ; Func exécute 10000 résultats : 4.6
2022.11.28 12:18:59.303 Test_AO_ACO (EURUSD,M1) 0,38333
2022.11.28 12:19:07.598 Test_AO_ACO (EURUSD,M1) 20 Megacity ; Func exécute 10000 résultats : 5,28
2022.11.28 12:19:07.598 Test_AO_ACO (EURUSD,M1) 0,44000
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) 500 Megacity ; Func exécute 10000 résultats : 0,2852
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) 0,02377
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) Tous les scores pour C_AO_ACOm : 0,4980520084646583

(Colonie d'Abeilles Artificielles) résultats du test :

2022.11.28 12:35:47.181 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:35:52.581 Test_AO_ABCm (EURUSD,M1) 1 Skin ; Func exécute 10000 résultats : 4,918379986612587
2022.11.28 12:35:52.581 Test_AO_ABCm (EURUSD,M1) 1,00000
2022.11.28 12:35:59.454 Test_AO_ABCm (EURUSD,M1) 20 Skin ; Func exécute 10000 résultats : 3,4073825805846374
2022.11.28 12:35:59.454 Test_AO_ABCm (EURUSD,M1) 0,63922
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) 500 Skin ; Func exécute 10000 résultats : 1,0684464927353337
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) 0,08076
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:36:38.086 Test_AO_ABCm (EURUSD,M1) 1 Forest ; Func exécute 10000 résultats : 1,766245456669898
2022.11.28 12:36:38.086 Test_AO_ABCm (EURUSD,M1) 0,99908
2022.11.28 12:36:45.326 Test_AO_ABCm (EURUSD,M1) 20 Forest ; Func exécute 10000 résultats : 0,35556125136004335
2022.11.28 12:36:45.326 Test_AO_ABCm (EURUSD,M1) 0,20112
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) 500 Forest ; Func exécute 10000 résultats : 0,06691711149962026
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) 0,03785
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:37:28.047 Test_AO_ABCm (EURUSD,M1) 1 Megacity ; Func exécute 10000 résultats : 12,0
2022.11.28 12:37:28.047 Test_AO_ABCm (EURUSD,M1) 1,00000
2022.11.28 12:37:35.689 Test_AO_ABCm (EURUSD,M1) 20 Megacity ; Func exécute 10000 résultats : 1,9600000000000002
2022.11.28 12:37:35.689 Test_AO_ABCm (EURUSD,M1) 0,16333
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) 500 Megacity ; Func exécute 10000 résultats : 0,33880000000000005
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) 0,02823
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) Tous les scores pour C_AO_ABCm : 0,4610669021761763

Résultats du test ABC (colonie d'abeilles artificielles) :

2022.11.28 12:29:51.177 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:29:56.785 Test_AO_ABC (EURUSD,M1) 1 Skin ; Func exécute 10000 résultats : 4,890679983950205
2022.11.28 12:29:56.785 Test_AO_ABC (EURUSD,M1) 0,99339
2022.11.28 12:30:03.880 Test_AO_ABC (EURUSD,M1) 20 Skin; Func exécute 10000 résultats : 3,8035430744604133
2022.11.28 12:30:03.880 Test_AO_ABC (EURUSD,M1) 0,73381
2022.11.28 12:30:37.089 Test_AO_ABC (EURUSD,M1) 500 Skin; Func exécute 10000 résultats : 1,195840100227333
2022.11.28 12:30:37.089 Test_AO_ABC (EURUSD,M1) 0,11118
2022.11.28 12:30:37.089 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:30:42.811 Test_AO_ABC (EURUSD,M1) 1 Forest ; Func exécute 10000 résultats : 1,7667070507449298
2022.11.28 12:30:42.811 Test_AO_ABC (EURUSD,M1) 0,99934
2022.11.28 12:30:50.108 Test_AO_ABC (EURUSD,M1) 20 Forest ; Func exécute 10000 résultats : 0,3789854806095275
2022.11.28 12:30:50.108 Test_AO_ABC (EURUSD,M1) 0,21437
2022.11.28 12:31:25.900 Test_AO_ABC (EURUSD,M1) 500 Forest ; Func exécute 10000 résultats : 0,07451308481273813
2022.11.28 12:31:25.900 Test_AO_ABC (EURUSD,M1) 0,04215
2022.11.28 12:31:25.900 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:31:31.510 Test_AO_ABC (EURUSD,M1) 1 Megacity ; Func exécute 10000 résultats : 10,2
2022.11.28 12:31:31.510 Test_AO_ABC (EURUSD,M1) 0,85000
2022.11.28 12:31:38.855 Test_AO_ABC (EURUSD,M1) 20 Megacity ; Func exécute 10000 résultats : 2,02
2022.11.28 12:31:38.855 Test_AO_ABC (EURUSD,M1) 0,16833
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) 500 Megacity ; Func exécute 10000 résultats : 0,37559999999999993
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) 0,03130
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) Tous les scores pour C_AO_ABC : 0,46043003186219245

Résultats du test PSO (Particle Swarm Optimization)

2022.11.28 12:01:03.967 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:01:09.723 Test_AO_PSO (EURUSD,M1) 1 Skin ; Func exécute 10000 résultats : 4,90276049713715
2022.11.28 12:01:09.723 Test_AO_PSO (EURUSD,M1) 0,99627
2022.11.28 12:01:17.064 Test_AO_PSO (EURUSD,M1) 20 Skin ; Func exécute 10000 résultats : 2,3250668562024566
2022.11.28 12:01:17.064 Test_AO_PSO (EURUSD,M1) 0,38080
2022.11.28 12:01:52.880 Test_AO_PSO (EURUSD,M1) 500 Skin ; Func exécute 10000 résultats : 0,943331687769892
2022.11.28 12:01:52.881 Test_AO_PSO (EURUSD,M1) 0,05089
2022.11.28 12:01:52.881 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:01:58.492 Test_AO_PSO (EURUSD,M1) 1 Forest ; Func exécute 10000 résultats : 1,6577769478566602
2022.11.28 12:01:58.492 Test_AO_PSO (EURUSD,M1) 0,93772
2022.11.28 12:02:06.105 Test_AO_PSO (EURUSD,M1) 20 Forest ; Func exécute 10000 résultats : 0,25704414127018393
2022.11.28 12:02:06.105 Test_AO_PSO (EURUSD,M1) 0,14540
2022.11.28 12:02:44.566 Test_AO_PSO (EURUSD,M1) 500 Forest ; Func exécute 10000 résultats : 0,08584805450831333
2022.11.28 12:02:44.566 Test_AO_PSO (EURUSD,M1) 0,04856
2022.11.28 12:02:44.566 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:02:50.268 Test_AO_PSO (EURUSD,M1) 1 Megacity ; Func exécute 10000 résultats : 12,0
2022.11.28 12:02:50.268 Test_AO_PSO (EURUSD,M1) 1,00000
2022.11.28 12:02:57.649 Test_AO_PSO (EURUSD,M1) 20 Megacity ; Func exécute 10000 résultats : 1,1199999999999999
2022.11.28 12:02:57.649 Test_AO_PSO (EURUSD,M1) 0,09333
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) 500 Megacity ; Func exécute 10000 résultats : 0,268
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) 0,02233
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) Tous les scores pour C_AO_PSO : 0,40836715689743186

Résultats du test RND (aléatoire) :

2022.11.28 16:45:15.976 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:45:21.569 Test_AO_RND (EURUSD,M1) 1 Skin ; Func exécute 10000 résultats : 4,915522750114194
2022.11.28 16:45:21.569 Test_AO_RND (EURUSD,M1) 0,99932
2022.11.28 16:45:28.607 Test_AO_RND (EURUSD,M1) 20 Skin; Func exécute 10000 résultats : 2,584546688199847
2022.11.28 16:45:28.607 Test_AO_RND (EURUSD,M1) 0,44276
2022.11.28 16:46:02.695 Test_AO_RND (EURUSD,M1) 500 Skin ; Func exécute 10000 résultats : 1,0161336237263792
2022.11.28 16:46:02.695 Test_AO_RND (EURUSD,M1) 0,06827
2022.11.28 16:46:02.695 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:46:09.622 Test_AO_RND (EURUSD,M1) 1 Forest ; Func exécute 10000 résultats : 1,4695680943894533
2022.11.28 16:46:09.622 Test_AO_RND (EURUSD,M1) 0,83126
2022.11.28 16:46:17.675 Test_AO_RND (EURUSD,M1) 20 Forest ; Func exécute 10000 résultats : 0,20373533112604475
2022.11.28 16:46:17.675 Test_AO_RND (EURUSD,M1) 0,11524
2022.11.28 16:46:54.544 Test_AO_RND (EURUSD,M1) 500 Forest ; Func exécute 10000 résultats : 0,0538909816827325
2022.11.28 16:46:54.544 Test_AO_RND (EURUSD,M1) 0,03048
2022.11.28 16:46:54.544 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:47:00.219 Test_AO_RND (EURUSD,M1) 1 Megacity ; Func exécute 10000 résultats : 10,0
2022.11.28 16:47:00.219 Test_AO_RND (EURUSD,M1) 0,83333
2022.11.28 16:47:08.145 Test_AO_RND (EURUSD,M1) 20 Megacity ; Func exécute 10000 résultats : 1,08
2022.11.28 16:47:08.145 Test_AO_RND (EURUSD,M1) 0,09000
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) 500 Megacity ; Func exécute 10000 résultats : 0,28840000000000005
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) 0,02403
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) Tous les scores pour C_AO_RND : 0,38163317904126015

Skin

GWO sur la fonction de test Skin

Forest

GWO sur la fonction de test Forest

Megacity

GWO sur la fonction de test Megacity

Résultats des tests GWO :

2022.11.28 13:24:09.370 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:24:14.895 Test_AO_GWO (EURUSD,M1) 1 Skin ; Func exécute 10000 résultats : 4,914175888065222
2022.11.28 13:24:14.895 Test_AO_GWO (EURUSD,M1) 0,99900
2022.11.28 13:24:22.175 Test_AO_GWO (EURUSD,M1) 20 Skin; Func exécute 10000 résultats : 2,7419092435309405
2022.11.28 13:24:22.175 Test_AO_GWO (EURUSD,M1) 0,48033
2022.11.28 13:25:01.381 Test_AO_GWO (EURUSD,M1) 500 Skin; Func exécute 10000 résultats : 1,5227848592798188
2022.11.28 13:25:01.381 Test_AO_GWO (EURUSD,M1) 0,18924
2022.11.28 13:25:01.381 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:25:06.924 Test_AO_GWO (EURUSD,M1) 1 Forest ; Func exécute 10000 résultats : 1,4822580151819842
2022.11.28 13:25:06.924 Test_AO_GWO (EURUSD,M1) 0,83844
2022.11.28 13:25:14.551 Test_AO_GWO (EURUSD,M1) 20 Forest ; Func exécute 10000 résultats : 0,15477395149266915
2022.11.28 13:25:14.551 Test_AO_GWO (EURUSD,M1) 0,08755
2022.11.28 13:25:56.900 Test_AO_GWO (EURUSD,M1) 500 Forest ; Func exécute 10000 résultats : 0,04517298232457319
2022.11.28 13:25:56.900 Test_AO_GWO (EURUSD,M1) 0,02555
2022.11.28 13:25:56.900 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:26:02.305 Test_AO_GWO (EURUSD,M1) 1 Megacity ; Func exécute 10000 résultats : 12,0
2022.11.28 13:26:02.305 Test_AO_GWO (EURUSD,M1) 1,00000
2022.11.28 13:26:09.475 Test_AO_GWO (EURUSD,M1) 20 Megacity ; Func exécute 10000 résultats : 1,2
2022.11.28 13:26:09.475 Test_AO_GWO (EURUSD,M1) 0,10000
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) 500 Megacity ; Func exécute 10000 résultats : 0,2624
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) 0,02187
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) Tous les scores pour C_AO_GWO : 0,41577484361261224

L'algorithme d'Optimisation des Loups Gris (GWO) est l'un des récents algorithmes d'optimisation bio-inspirés basés sur la chasse simulée d'une meute de loups gris. En moyenne, l'algorithme s'est avéré assez efficace sur différents types de fonctions, tant en termes de précision de recherche d'un extremum qu'en termes de vitesse de convergence. Dans certains tests, il s'est avéré être le meilleur. Les principaux indicateurs de performance de l'algorithme d'optimisation "Gray Wolves" sont meilleurs que ceux de l'algorithme d'optimisation par essaim de particules, considéré comme "conventionnel" dans la classe des algorithmes d'optimisation bio-inspirés.

De plus, la complexité de calcul de l'algorithme d'optimisation des Loups Gris est comparable à l'algorithme d'optimisation des essaims de particules. En raison des nombreux avantages de l'algorithme d'optimisation GWO, de nombreux travaux sur sa modification sont apparus en peu de temps depuis la première publication de l'algorithme. Le seul inconvénient de l'algorithme est la faible précision des coordonnées trouvées de la fonction de maximum net Forest.

La faible précision de l'extremum trouvé s'est manifestée dans toutes les dimensions de la fonction Forest. Ses résultats sont les pires parmi tous les participants du tableau. L'algorithme s'est avéré efficace sur la fonction Skin lisse, en particulier dans le cas de la fonction Skin de plus grande dimension. GWO est également troisième dans le tableau pour atteindre un succès de 100% dans le maximum global sur la fonction Megacity.

AO	Description	Skin			Forest			Megacity (discrète)			Résultat final
AO	Description	2 paramètres (1 F)	40 paramètres (20 F)	1.000 paramètres (500 F)	2 paramètres (1 F)	40 paramètres (20 F)	1.000 paramètres (500 F)	2 paramètres (1 F)	40 paramètres (20 F)	1.000 paramètres (500 F)	Résultat final
ACOm	optimisation des colonies de fourmis	0,98229	0,79108	0,12602	1,00000	0,62077	0,11521	0,38333	0,44000	0,02377	0,49805222
ABCm	colonie d'abeilles artificielles M	1,00000	0,63922	0,08076	0,99908	0,20112	0,03785	1,00000	0,16333	0,02823	0,46106556
ABC	colonie d'abeilles artificielles	0,99339	0,73381	0,11118	0,99934	0,21437	0,04215	0,85000	0,16833	0,03130	0,46043000
GWO	optimiseur de loup gris	0,99900	0,48033	0,18924	0,83844	0,08755	0,02555	1,00000	0,10000	0,02187	0,41577556
PSO	optimisation des essaims de particules	0,99627	0,38080	0,05089	0,93772	0,14540	0,04856	1,00000	0,09333	0,02233	0,40836667
RND	aléatoire	0,99932	0,44276	0,06827	0,83126	0,11524	0,03048	0,83333	0,09000	0,02403	0,38163222

Conclusion

Avantages :
1. Grande vitesse
2. Convergence élevée pour les fonctions lisses avec un grand nombre de variables

Inconvénients :
1. Pas universel
2. Se coince dans les extrêmes locaux
3. Faible évolutivité sur les fonctions discrètes et non différentiables

Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/11785

Fichiers joints |

Télécharger ZIP

l5_The_world_of_AO_oGWOv.zip (44.97 KB)

Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Aller à la discussion

Algorithmes d'optimisation de la population : Algorithme d'Optimisation du Coucou - Cuckoo Optimization Algorithm (COA)

Le nouvel algorithme que je considérerai est l'optimisation de la recherche de coucou à l'aide des vols de Levy. C'est l'un des derniers algorithmes d'optimisation et un nouveau leader dans le classement.

Apprendre à concevoir un système de trading basé sur le VIDYA

Bienvenue dans ce nouvel article de notre série consacrée à l'apprentissage de la conception d'un système de trading à l'aide des indicateurs techniques les plus populaires. Dans cet article, nous allons découvrir un nouvel outil technique et apprendre à concevoir un système de trading à l'aide de la Moyenne Dynamique à Indice Variable, ou en anglais le Variable Index Dynamic Average (VIDYA).

Apprendre à concevoir un système de trading basé sur DeMarker

Voici un nouvel article de notre série sur la conception d'un système de trading à partir des indicateurs techniques les plus populaires. Dans cet article, nous allons présenter comment créer un système de trading à l'aide de l'indicateur DeMarker.

Apprenez à concevoir un système de trading basé sur le Pouvoir des Haussiers (Bulls Power)

Bienvenue dans ce nouvel article de notre série sur l'apprentissage de la conception d'un système de trading à l'aide des indicateurs techniques les plus populaires. Nous allons découvrir dans cet article un nouvel indicateur technique et comment nous pouvons concevoir un système de trading à l'aide de cet indicateur, le Bulls Power.