MetaTrader 5 / Exemples
English Русский 中文 Español Deutsch 日本語 Português 한국어 Italiano Türkçe
preview
Algorithmes d'optimisation de la population : Algorithme de la Chauve-Souris (BA)

Algorithmes d'optimisation de la population : Algorithme de la Chauve-Souris (BA)

MetaTrader 5 — Exemples | 6 décembre 2023, 09:32
1 161 0
Andrey Dik
Andrey Dik

Sommaire

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


1. Introduction

Les chauves-souris sont des animaux étonnants. Les scientifiques pensent que les premières chauves-souris sont apparues il y a 65 à 100 millions d'années, aux côtés des dinosaures. Les chauves-souris sont les seuls mammifères ailés. Les chauves-souris comptent plus de 1300 espèces. On les trouve presque partout, sauf dans les régions polaires. Pendant la journée, elles se cachent dans des abris. Pour naviguer dans les grottes sombres et chasser après la tombée de la nuit, les chauves-souris utilisent l'écho-localisation, un système qui leur permet de détecter des objets à l'aide d'ondes sonores. L'écho-localisation consiste à émettre un son à haute fréquence qui se déplace vers l'avant jusqu'à ce qu'il touche un objet et qu'il soit réfléchi. L'écho-localisation est une sorte de sonar : une chauve-souris émet un son fort et bref. Lorsque le son atteint un objet, l'écho revient aux oreilles de la chauve-souris après un certain laps de temps. C'est ainsi que les chauves-souris s'orientent dans l'espace et déterminent la position de leurs proies. 

L'algorithme Bat (BA) est un algorithme heuristique introduit par Yang en 2010 qui imite le comportement d'écho-localisation des chauves-souris pour effectuer une optimisation globale. Les métaheuristiques, généralement inspirées de la nature et des processus physiques, sont désormais utilisées comme l'une des techniques les plus puissantes pour résoudre de nombreux problèmes d'optimisation complexes. L'optimisation est la sélection des meilleurs éléments pour un certain ensemble de critères à partir d'un certain nombre d'options efficaces. Cela présente de nombreux avantages et inconvénients en termes d'efficacité de calcul et de probabilité d'optimisation globale.

L'optimisation des fonctions offre un cadre formel pour la modélisation et la résolution d'un certain nombre de problèmes spécifiques en fournissant une fonction "cible" qui prend un paramètre en entrée. L'objectif est de trouver la valeur du paramètre combiné qui renvoie la meilleure valeur. Ce cadre est suffisamment abstrait pour que divers problèmes puissent être interprétés comme des problèmes d'"optimisation des caractéristiques".


Mais l'optimisation traditionnelle des caractéristiques n'est utilisée que pour résoudre quelques petits problèmes, qui ne sont souvent pas applicables dans la pratique. C'est pourquoi les scientifiques se tournent vers la nature, qui offre de riches modèles pour résoudre ces problèmes. En modélisant les systèmes biologiques naturels, de nombreux algorithmes d'optimisation par essaims intelligents sont proposés pour résoudre des problèmes appliqués à l'aide de méthodes non conventionnelles. Ils sont largement utilisés dans divers problèmes d'optimisation en raison de leurs excellentes performances. Le BA est un algorithme nouveau et moderne, de type essaim, qui effectue un processus de recherche en utilisant des chauves-souris artificielles comme agents de recherche, simulant le volume d'impulsion sonore naturel et la fréquence d'émission de vraies chauves-souris.


2. Description de l'algorithme

Dans l'algorithme de base des chauves-souris, chaque chauve-souris est traitée comme une particule "sans masse et sans taille" représentant une solution valide dans l'espace de solution. Pour les différentes fonctions d'aptitude, chaque chauve-souris a une valeur de caractéristique correspondante et détermine l'individu optimal actuel en comparant les valeurs de caractéristique. La fréquence de l'onde acoustique, la vitesse, la vitesse d'émission des impulsions et le volume de chaque chauve-souris de la population sont ensuite mis à jour. L'évolution itérative se poursuit, la solution optimale actuelle est approximée et générée, et enfin la solution optimale globale est trouvée. L'algorithme met à jour la fréquence, la vitesse et la position de chaque chauve-souris.

L'algorithme standard requiert 5 paramètres de base : la fréquence, l'intensité sonore, l'ondulation et les ratios d'intensité sonore et d'ondulation. La fréquence est utilisée pour équilibrer l'impact de la meilleure position historique sur la position actuelle. Une chauve-souris individuelle cherchera loin de la position historique du groupe lorsque la gamme de fréquences de recherche est large. Et inversement.

Les paramètres de l'algorithme sont assez nombreux par rapport à ceux qui ont été pris en compte précédemment :

input double MIN_FREQ_P          = 0.0;
input double MAX_FREQ_P         = 1.0;
input double MIN_LOUDNESS_P  = 0.0;
input double MAX_LOUDNESS_P = 1.5;
input double MIN_PULSE_P        = 0.0;
input double MAX_PULSE_P        = 1.0;
input double ALPHA_P               = 0.3;
input double GAMMA_P              = 0.3;

Lors de l’implémentation de l'algorithme BA, j'ai constaté que, dans de nombreuses sources, les auteurs des articles décrivent l'algorithme de manière totalement différente. Les différences se situent à la fois dans l'utilisation des termes dans la description des points clés et dans les caractéristiques algorithmiques fondamentales. C'est pourquoi je décrirai comment je l'ai compris moi-même. Les principes physiques de base qui sous-tendent l'écho-localisation peuvent être appliqués à l'algorithme avec des réserves et des conventions importantes. Nous supposons que les chauves-souris utilisent des impulsions sonores dont la fréquence est comprise entre MinFreq et MaxFreq. La fréquence affecte la vitesse de la chauve-souris. Le concept conditionnel de l'intensité sonore est également utilisé, ce qui affecte la transition de l'état de recherche locale à l'emplacement de la position actuelle de la chauve-souris à l'état de recherche globale à proximité de la meilleure solution. La fréquence des pulsations augmente tout au long de l'optimisation, et le volume des sons diminue.

Pseudo-code de l'algorithme BA (Fig. 1) :

1. Initialisation de la population des chauves-souris.
2. Génération de la fréquence, de la vitesse et de nouvelles solutions.
3. Recherche d’une solution locale.
4. Mise à jour de la solution globale.
5. Diminution du volume et augmentation de la fréquence de pulsation.
6. Répétition depuis l'étape 2 jusqu'à ce que le critère d'arrêt soit rempli.

schéma

Fig. 1 : Schéma fonctionnel de l'algorithme BA

Commençons par décrire le code. Pour décrire l'agent de recherche "bat", nous avons besoin d'une structure dans laquelle toutes les caractéristiques nécessaires à une description complète de l'état au moment de chaque itération sont présentes. Le tableau position[] est utilisé pour stocker les coordonnées de la meilleure position dans l'espace. Le tableau auxPosition[] est utilisé pour les coordonnées "opérationnelles" actuelles. Le tableau speed[] est nécessaire au calcul du vecteur vitesse par coordonnées. frequency est la fréquence des impulsions sonores, initPulseRate, le taux d'impulsion initial (individuel pour chaque chauve-souris dès le début de l'optimisation), pulseRate est le taux d'impulsion à l'itération actuelle, loudness est l’intensité sonore des impulsions sonores, fitness est la valeur de la fonction fitness après le dernier mouvement et fitnessBest, la meilleure valeur de la fonction fitness de l'agent pour l'ensemble des itérations.  

//——————————————————————————————————————————————————————————————————————————————
struct S_Bat
{
  double position    [];
  double auxPosition [];
  double speed       [];
  double frequency;
  double initPulseRate;
  double pulseRate;
  double loudness;
  double fitness;
  double fitnessBest;
};
//——————————————————————————————————————————————————————————————————————————————

La classe bat comprend un tableau de structures d'agents de recherche, les limites et les étapes de l'espace exploré, les meilleures coordonnées trouvées par l'algorithme, la meilleure valeur de la fonction d'aptitude et des constantes pour stocker les paramètres de l'algorithme. Elle contient la méthode d'initialisation publique, deux méthodes publiques requises pour fonctionner avec l'algorithme et des méthodes privées spécifiques à l'algorithme. 

//——————————————————————————————————————————————————————————————————————————————
class C_AO_BA
{
  //============================================================================
  public: S_Bat  bats      []; //bats
  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //manimum search range
  public: double rangeStep []; //step search
  public: double cB        []; //best coordinates
  public: double fB;           //FF of the best coordinates

  public: void Init (const int    paramsP,
                     const int    batsNumberP,
                     const double min_FREQ_P,
                     const double max_FREQ_P,
                     const double min_LOUDNESS_P,
                     const double max_LOUDNESS_P,
                     const double min_PULSE_P,
                     const double max_PULSE_P,
                     const double alpha_P,
                     const double gamma_P,
                     const int    maxIterP);

  public: void Flight (int epoch);
  public: void Preparation ();

  //============================================================================
  private: void Walk               (S_Bat &bat);
  private: void AproxBest          (S_Bat &bat, double averageLoudness);
  private: void AcceptNewSolutions (S_Bat &bat);
  private: int  currentIteration;
  private: int  maxIter;

  private: double MIN_FREQ;
  private: double MAX_FREQ;

  private: double MIN_LOUDNESS;
  private: double MAX_LOUDNESS;

  private: double MIN_PULSE;
  private: double MAX_PULSE;

  private: double ALPHA;
  private: double GAMMA;

  private: int    params;
  private: int    batsNumber;

  private: bool   firstFlight;

  private: double SeInDiSp  (double In, double inMin, double inMax, double step);
  private: double RNDfromCI (double min, double max);
  private: double Scale     (double In, double InMIN, double InMAX, double OutMIN, double OutMAX,  bool revers);
};
//——————————————————————————————————————————————————————————————————————————————

Dans la méthode publique Init() de l’algorithme définissant les paramètres, nous allouons la mémoire pour les tableaux, nous réinitialisons la variable à la valeur minimale pour stocker le meilleur ajustement, ainsi que le drapeau de l'itération initiale. En général, cette méthode n'est pas compliquée.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_BA::Init (const int    paramsP,
                    const int    batsNumberP,
                    const double min_FREQ_P,
                    const double max_FREQ_P,
                    const double min_LOUDNESS_P,
                    const double max_LOUDNESS_P,
                    const double min_PULSE_P,
                    const double max_PULSE_P,
                    const double alpha_P,
                    const double gamma_P,
                    const int    maxIterP)
{
  MathSrand (GetTickCount ());

  fB = -DBL_MAX;

  params       = paramsP;
  batsNumber   = batsNumberP;
  MIN_FREQ     = min_FREQ_P;
  MAX_FREQ     = max_FREQ_P;
  MIN_LOUDNESS = min_LOUDNESS_P;
  MAX_LOUDNESS = max_LOUDNESS_P;
  MIN_PULSE    = min_PULSE_P;
  MAX_PULSE    = max_PULSE_P;
  ALPHA        = alpha_P;
  GAMMA        = gamma_P;
  maxIter      = maxIterP;

  ArrayResize (rangeMax,  params);
  ArrayResize (rangeMin,  params);
  ArrayResize (rangeStep, params);

  firstFlight = false;

  ArrayResize (bats, batsNumber);

  for (int i = 0; i < batsNumber; i++)
  {
    ArrayResize (bats [i].position,    params);
    ArrayResize (bats [i].auxPosition, params);
    ArrayResize (bats [i].speed,       params);

    bats [i].fitness  = -DBL_MAX;
  }

  ArrayResize (cB, params);
}
//——————————————————————————————————————————————————————————————————————————————

La première méthode appelée à chaque itération est Flight(). Elle concentre le cadre principal de la logique de recherche, et le reste des détails est placé dans des méthodes privées auxiliaires spécifiques à cet algorithme d'optimisation. Lors de la toute première itération, le drapeau firstFlight est réinitialisé (la réinitialisation a lieu lors de l'initialisation dans la méthode Init()). Cela signifie que nous devons attribuer un état initial à chaque chauve-souris. L’état initial est une position aléatoire dans l'espace de recherche :

  • vitesse zéro,
  • fréquence individuelle des impulsions sonores attribuée par un nombre aléatoire dans la plage spécifiée par les paramètres,
  • fréquence de pulsation individuelle initiale définie par un nombre aléatoire dans la plage de paramètres
  • l'intensité des impulsions sonores dans la plage de paramètres.

Comme vous pouvez le constater, chaque chauve-souris artificielle possède un ensemble individuel de caractéristiques de signaux sonores, ce qui les rend plus proches des vraies chauves-souris dans la nature. Dans l'ensemble de la population, qui peut compter plusieurs centaines de milliers d'individus, une mère peut retrouver un seul petit grâce à la signature sonore unique qu'émet le bébé.

Si l'indicateur de premier vol est activé, il est nécessaire d'effectuer des opérations de base pour déplacer les chauves-souris. L'une des caractéristiques intéressantes de l'algorithme réside dans le concept de l'intensité sonore moyenne de l'ensemble de la population. En général, l'intensité sonore diminue par le biais du coefficient "alpha" au cours de toutes les itérations. Il existe 2 types de mouvements de chauve-souris : Walk() - mouvement individuel avec calcul du vecteur vitesse pour chaque composante de coordonnées et mouvement local à proximité de la meilleure solution.

À chaque itération suivante, l'intensité des pulsations diminue, ce qui affecte l'intensité de l'exploration du voisinage. L'exploration et l'exploitation évoluent ainsi de manière dynamique tout au long de l'optimisation. Nous verrons ensuite comment l'itération en cours affecte le comportement des chauves-souris.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_BA::Flight (int epoch)
{
  currentIteration = epoch;

  //============================================================================
  if (!firstFlight)
  {
    fB = -DBL_MAX;

    //--------------------------------------------------------------------------
    for (int b = 0; b < batsNumber; b++)
    {
      for (int p = 0; p < params; p++)
      {
        bats [b].position    [p] = RNDfromCI (rangeMin [p], rangeMax [p]);
        bats [b].position    [p] = SeInDiSp (bats [b].position [p], rangeMin [p], rangeMax [p], rangeStep [p]);
        bats [b].auxPosition [p] = bats [b].position    [p];
        bats [b].speed       [p] = 0.0;
        bats [b].frequency       = RNDfromCI (MIN_FREQ, MAX_FREQ);
        bats [b].initPulseRate   = RNDfromCI (MIN_PULSE, MAX_PULSE / 2);
        bats [b].pulseRate       = bats [b].initPulseRate;
        bats [b].loudness        = RNDfromCI (MAX_LOUDNESS / 2, MAX_LOUDNESS);
        bats [b].fitness         = -DBL_MAX;
        bats [b].fitnessBest     = -DBL_MAX;
      }
    }

    firstFlight = true;
  }
  //============================================================================
  else
  {
    double avgLoudness = 0;

    for (int b = 0; b < batsNumber; b++)
    {
      avgLoudness += bats [b].loudness;
    }

    avgLoudness /= batsNumber;

    for (int b = 0; b < batsNumber; b++)
    {
      Walk (bats [b]);

      if (RNDfromCI (MIN_PULSE, MAX_PULSE) > bats [b].pulseRate)
      {
        AproxBest (bats [b], avgLoudness);
      }
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

La deuxième méthode publique requise, Preparation() , est appelée à chaque itération. Elle est nécessaire pour mettre à jour la meilleure solution globale. On voit ici comment le concept de "loudness" est utilisé. Étant donné qu'à chaque itération, le volume de chaque souris diminue d'un certain facteur (paramètre de réglage de l'algorithme "alpha"), la probabilité d'une étude locale diminue en même temps que l'intensité de l'étude de la solution globale. En d'autres termes, la probabilité de mettre à jour la meilleure position de chaque chauve-souris diminue à chaque itération. C'est l'une des parties de l'algorithme que je comprends le moins bien. Mais l'auteur de l'algorithme l'a mise en œuvre, c’est donc qu’elle est nécessaire.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_BA::Preparation ()
{
  //----------------------------------------------------------------------------
  for (int b = 0; b < batsNumber; b++)
  {
    if (bats [b].fitness > fB)
    {
      fB = bats [b].fitness;
      ArrayCopy (cB, bats [b].auxPosition, 0, 0, WHOLE_ARRAY);
    }
  }

  //----------------------------------------------------------------------------
  for (int b = 0; b < batsNumber; b++)
  {
    if (RNDfromCI (MIN_LOUDNESS, MAX_LOUDNESS) < bats [b].loudness && bats [b].fitness >= bats [b].fitnessBest)
    {
      AcceptNewSolutions (bats [b]);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

La méthode privée Walk() garantit que chaque chauve-souris se déplace individuellement par rapport à sa meilleure position actuelle, compte tenu de la meilleure solution globale. Cette méthode utilise la fréquence des impulsions sonores, qui varie de manière aléatoire dans la plage [MIN_FREQ ; MAX_FREQ]. La fréquence est nécessaire pour calculer la vitesse de déplacement de l'agent de recherche. La vitesse de déplacement est le produit de la fréquence par la différence entre la meilleure position de la souris et la meilleure solution globale. La valeur de la vitesse est ensuite ajoutée à la meilleure solution actuelle de la chauve-souris, vecteur par vecteur. Nous travaillons donc avec des quantités physiques disproportionnées. Mais que pouvons-nous faire ? Il ne s'agit que d'une approximation des objets physiques réels. Il est possible de négliger cette possibilité dans ce cas. Après avoir calculé la nouvelle position, il convient de vérifier que les coordonnées ne sont pas en dehors de la plage à l'aide de la méthode SeInDiSp().

//——————————————————————————————————————————————————————————————————————————————
void C_AO_BA::Walk (S_Bat &bat)
{
  for (int j = 0; j < params; ++j)
  {
    bat.frequency       = MIN_FREQ + (MAX_FREQ - MIN_FREQ) * RNDfromCI (0.0, 1.0);
    bat.speed       [j] = bat.speed [j] + (bat.position [j] - cB [j]) * bat.frequency;
    bat.auxPosition [j] = bat.position [j] + bat.speed [j];

    bat.auxPosition [j] = SeInDiSp (bat.auxPosition [j], rangeMin [j], rangeMax [j], rangeStep [j]);
  }
}
//——————————————————————————————————————————————————————————————————————————————

La deuxième méthode privée, AproxBest(), est chargée de déplacer les chauves-souris par rapport à la meilleure solution globale. Cela permet d'affiner davantage les coordonnées. Il ne m'est pas possible de comprendre le sens physique de cette action, qui consiste à ajouter, vecteur par vecteur, aux coordonnées l'incrément sous la forme de l'intensité sonore moyenne de toute la population de chauves-souris, multipliée par un nombre aléatoire dans l'intervalle [-1,0 ; 1,0]. J'ai essayé de réduire les valeurs à la dimension de la fonction optimisée par le biais du vecteur des valeurs valides du domaine de définition. Mais les résultats des tests se sont avérés moins bons que dans la version de l'algorithme de l'auteur. J’ai donc tout laissé tel quel. Mais je suis sûr que l'efficacité de l'algorithme BA peut être améliorée. Cela nécessitera par contre des recherches supplémentaires, ce qui n'était pas l'objectif dans ce cas. Après avoir calculé les coordonnées, on vérifie que les valeurs ne sont pas en dehors de l’intervalle à l'aide de la méthode SeInDiSp(). 

//——————————————————————————————————————————————————————————————————————————————
void C_AO_BA::AproxBest (S_Bat &bat, double averageLoudness)
{
  for (int j = 0; j < params; ++j)
  {
    bat.auxPosition [j] = cB [j] + averageLoudness * RNDfromCI (-1.0, 1.0);
    bat.auxPosition [j] = SeInDiSp (bat.auxPosition [j], rangeMin [j], rangeMax [j], rangeStep [j]);
  }
}
//——————————————————————————————————————————————————————————————————————————————

Une autre méthode privée spécifique est AcceptNewSolutions(). Cette fonction est appelée lorsque la condition de test pour la fréquence des impulsions sonores de chaque chauve-souris est remplie. La nouvelle meilleure solution individuelle est acceptée, et l'intensité sonore individuelle et la fréquence de pulsation individuelle sont recalculées ici. On voit ici comment le numéro ordinal d'une itération intervient dans le calcul de la fréquence de la pulsation.

À ce stade de la logique de l'algorithme, j'ai pris quelques libertés et j'ai modifié la logique, en rendant le résultat indépendant de la dimension du nombre total d'itérations, ce qui, en fin de compte, a légèrement augmenté l'efficacité de l'algorithme. Dans la version originale, le nombre d'itérations était directement impliqué dans la formule non linéaire de calcul de la fréquence des impulsions. L’algorithme BA accueille déjà de nombreuses conventions. Je ne pouvais pas fermer les yeux sur un de plus dans ce cas. 

//——————————————————————————————————————————————————————————————————————————————
void C_AO_BA::AcceptNewSolutions (S_Bat &bat)
{
  ArrayCopy(bat.position, bat.auxPosition, 0, 0, WHOLE_ARRAY);
  bat.fitnessBest = bat.fitness;
  bat.loudness    = ALPHA * bat.loudness;
  double iter     = Scale (currentIteration, 1, maxIter, 0.0, 10.0, false);
  bat.pulseRate   = bat.initPulseRate *(1.0 - exp(-GAMMA * iter));
}
//——————————————————————————————————————————————————————————————————————————————

La dépendance de la fréquence de pulsation par rapport au numéro de l'itération en cours (x sur le graphique) et au paramètre de réglage GAMMA est illustrée à la figure 2.

gamma

Fig. 2 : Dépendance de la fréquence de pulsation sur le numéro de l'itération en cours et le paramètre de réglage GAMMA avec les valeurs 0,9, 0,7, 0,5, 0,3 et 0,2

3. Résultats des tests

Dans le dernier article, j'ai évoqué les projets de révision de la méthodologie de calcul de l'évaluation des algorithmes testés. Tout d'abord, étant donné que la plupart des algorithmes peuvent facilement traiter les fonctions de test à 2 variables et que la différence entre les résultats est presque indiscernable, j'ai décidé d'augmenter le nombre de variables pour les deux premiers tests sur toutes les fonctions de test. Le nombre de variables sera maintenant de 10, 50 et 1000.

Deuxièmement, la fonction de test Skin a été remplacée par la fonction de Rastrigin, largement utilisée (figure 3). Cette fonction est lissée comme la fonction Skin. Elle présente une surface complexe avec de nombreux extrema locaux, un maximum global en 4 points et un minimum global au centre des axes de coordonnées.

Troisièmement, j'ai décidé de normaliser les résultats des tests pour obtenir une fourchette de valeurs parmi tous les algorithmes du tableau, où le meilleur résultat est 1,0 et le plus mauvais 0,0. Cela nous permet d'évaluer uniformément les résultats des tests, alors que la complexité des fonctions est prise en compte en fonction des résultats de chacun des algorithmes d'optimisation testés.

Les résultats des tests des algorithmes sont ensuite résumés. 100 est le résultat maximal (résultat maximal de référence), et la valeur minimale est 1. Cela nous permet de comparer directement les algorithmes entre eux, même en tenant compte de la complexité des fonctions de test. Les résultats imprimés avec Print() sont maintenant enregistrés dans les fichiers sources des scripts de test pour chaque algorithme. Le script qui calcule les scores des tests est joint ci-dessous. Il sera mis à jour dans les articles suivants avec l'ajout des résultats des nouveaux algorithmes envisagés.



rastrigin

Fig. 3 : Fonction de test de Rastrigin

Les résultats du banc d'essai se présentent maintenant de la façon suivante : 

2022.12.28 17:13:46.384    Test_AO_BA (EURUSD,M1)    C_AO_BA:50;0.0;1.0;0.0;1.5;0.0;1.0;0.3;0.3
2022.12.28 17:13:46.384    Test_AO_BA (EURUSD,M1)    =============================
2022.12.28 17:13:48.451    Test_AO_BA (EURUSD,M1)    5 Rastrigin's; Func runs 10000 result: 66.63334336098077
2022.12.28 17:13:48.451    Test_AO_BA (EURUSD,M1)    Score: 0.82562
2022.12.28 17:13:52.630    Test_AO_BA (EURUSD,M1)    25 Rastrigin's; Func runs 10000 result: 65.51391114042588
2022.12.28 17:13:52.630    Test_AO_BA (EURUSD,M1)    Score: 0.81175
2022.12.28 17:14:27.234    Test_AO_BA (EURUSD,M1)    500 Rastrigin's; Func runs 10000 result: 59.84512760590815
2022.12.28 17:14:27.234    Test_AO_BA (EURUSD,M1)    Score: 0.74151
2022.12.28 17:14:27.234    Test_AO_BA (EURUSD,M1)    =============================
2022.12.28 17:14:32.280    Test_AO_BA (EURUSD,M1)    5 Forest's; Func runs 10000 result: 0.5861602092218606
2022.12.28 17:14:32.280    Test_AO_BA (EURUSD,M1)    Score: 0.33156
2022.12.28 17:14:39.204    Test_AO_BA (EURUSD,M1)    25 Forest's; Func runs 10000 result: 0.2895682720055589
2022.12.28 17:14:39.204    Test_AO_BA (EURUSD,M1)    Score: 0.16379
2022.12.28 17:15:14.716    Test_AO_BA (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.09867854051596259
2022.12.28 17:15:14.716    Test_AO_BA (EURUSD,M1)    Score: 0.05582
2022.12.28 17:15:14.716    Test_AO_BA (EURUSD,M1)    =============================
2022.12.28 17:15:20.843    Test_AO_BA (EURUSD,M1)    5 Megacity's; Func runs 10000 result: 3.3199999999999994
2022.12.28 17:15:20.843    Test_AO_BA (EURUSD,M1)    Score: 0.27667
2022.12.28 17:15:26.624    Test_AO_BA (EURUSD,M1)    25 Megacity's; Func runs 10000 result: 1.2079999999999997
2022.12.28 17:15:26.624    Test_AO_BA (EURUSD,M1)    Score: 0.10067
2022.12.28 17:16:05.013    Test_AO_BA (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.40759999999999996
2022.12.28 17:16:05.013    Test_AO_BA (EURUSD,M1)    Score: 0.03397

L'algorithme bat a donné des résultats impressionnants sur la fonction lisse de Rastrigin. Il est intéressant de noter qu'avec l'augmentation du nombre de variables dans la fonction, la stabilité (répétabilité) des résultats augmente, ce qui indique une excellente évolutivité de l’algorithme BA sur les fonctions lisses. L’algorithme BA s'est en particulier avéré être le meilleur sur la fonction de Rastrigin avec 50 et 1000 variables, ce qui nous permet de recommander l'algorithme bat pour travailler avec des fonctions lisses complexes et des réseaux neuronaux. Pour les fonctions Forest et Megacity, l'algorithme Bat a donné des résultats moyens, démontrant une tendance à s'enliser dans les extrêmes locaux. Les coordonnées sont localisées dans des groupes et ne montrent pas la dynamique du changement et le mouvement vers l'optimum global. Je pense que cela est dû au fait que l'algorithme est sensible à la présence d'un gradient sur la surface de la fonction étudiée. En l'absence de gradient, l'algorithme s'arrête rapidement à proximité des zones locales qui ne présentent pas d'augmentation significative des valeurs de la fonction d'aptitude. L'algorithme BA ne dispose pas non plus de mécanismes permettant de "sauter" vers de nouvelles zones inconnues, à l'instar du mécanisme mis en œuvre dans l'ACO (vols de Levy).

Je dois également mentionner un grand nombre de paramètres pour l’algorithme BA. Non seulement il existe de nombreux paramètres (degrés de liberté), mais chacun d'entre eux influe considérablement sur la nature des propriétés de recherche et sur les taux de convergence globaux. Certains paramètres peuvent donner d'excellents résultats sur des fonctions lisses, et d'autres sur des fonctions discrètes et fissurées. Il est difficile de trouver des paramètres universels qui permettent de traiter de manière égale différents types de fonctions d'essai. L'article présente le code source de l'algorithme bat avec les paramètres qui me semblent les plus optimaux. De façon générale, je ne recommanderais pas l'utilisation de BA aux utilisateurs qui ont peu d'expérience dans l'utilisation d'algorithmes d'optimisation, car les résultats de l'optimisation peuvent varier considérablement.  

rastrigin

  BA sur la fonction de test de Rastrigin

forest

BA sur la fonction de test forest

megacity

BA sur la fonction de test megacity

En se concentrant sur la visualisation des fonctions de test, on peut se faire une idée des caractéristiques de l'algorithme bat. Lorsqu'il travaille sur toutes les fonctions d'essai, l'algorithme se caractérise en particulier par le regroupement des coordonnées dans de très petites zones locales. Alors que pour une fonction lisse, cette caractéristique permet de se déplacer même lorsque le gradient de la fonction d'aptitude change légèrement, pour une fonction discrète, cette caractéristique s'avère être un inconvénient puisque l'algorithme reste bloqué sur des plateaux plats.

Résultats obtenus par le script calculant les scores des algorithmes d'optimisation :

2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_RND=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.18210 | 0.15281 | 0.07011 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.08623 | 0.04810 | 0.06094 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.00000 | 0.00000 | 0.08904 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.6893397068905002
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_PSO=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.22131 | 0.12861 | 0.05966 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.15345 | 0.10486 | 0.28099 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.08028 | 0.02385 | 0.00000 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    1.053004072893302
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_ACOm=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.37458 | 0.28208 | 0.17991 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    1.00000 | 1.00000 | 1.00000 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    1.00000 | 1.00000 | 0.10959 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    5.946151922377553
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_ABC=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.84599 | 0.51308 | 0.22588 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.58850 | 0.21455 | 0.17249 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.47444 | 0.26681 | 0.35941 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    3.661160435265267
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_GWO=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.00000 | 0.00000 | 0.00000 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.00000 | 0.00000 | 0.00000 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.18977 | 0.04119 | 0.01802 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.24898721240154956
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_COAm=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    1.00000 | 0.73390 | 0.28892 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.64504 | 0.34034 | 0.21362 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.67153 | 0.34273 | 0.45422 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    4.690306586791184
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_FSS=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.50663 | 0.39737 | 0.11006 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.07806 | 0.05013 | 0.08423 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.00000 | 0.01084 | 0.18998 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    1.4272897567648186
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_FAm=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.64746 | 0.53292 | 0.18102 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.55408 | 0.42299 | 0.64360 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.21167 | 0.28416 | 1.00000 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    4.477897116029613
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    =======C_AO_BA=======
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.43859 | 1.00000 | 1.00000 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.17768 | 0.17477 | 0.33595 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.15329 | 0.07158 | 0.46287 |
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    3.8147314003892507
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    ================
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    ================
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    ================
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    0.24898721240154956 | 5.946151922377553
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_RND: 8.652
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_PSO: 14.971
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_ACOm: 100.000
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_ABC: 60.294
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_GWO: 1.000
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_COAm: 78.177
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_FSS: 21.475
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_FAm: 74.486
2023.01.03 17:55:57.386    CalculationTestResults (EURUSD,M1)    C_AO_BA: 62.962

Jetons un coup d'œil au tableau d'évaluation finale. Comme indiqué plus haut, la méthodologie de calcul des caractéristiques estimées des algorithmes a changé, de sorte que les algorithmes ont pris une nouvelle position. Certains algorithmes classiques ont été supprimés du tableau et il ne reste que leurs versions modifiées, qui se révèlent plus performantes lors des tests. Les résultats des tests ne sont désormais plus absolus comme auparavant (résultats absolus normalisés des valeurs de la fonction de test), mais relatifs sur la base des résultats de la comparaison des algorithmes entre eux.

Le tableau montre qu'ACOm (Optimisation de la Colonie de Fournis, Ant Colony Optimization) est le leader du moment. L'algorithme a obtenu les meilleurs résultats dans 5 des 9 tests. Le résultat final est de 100 points. COAm, une version modifiée de l'algorithme d'optimisation du coucou, arrive en 2ème position. Cet algorithme s'est avéré être le meilleur sur la fonction de Rastrigin lisse et a également montré de bons résultats sur d'autres tests par rapport à d'autres participants au test. L'algorithme firefly modifié FAm a pris la 3ème place. Il a donné les meilleurs résultats sur la fonction discrète Megacity. Seul le SIV a obtenu le même résultat lors de ce test.

AO

Description

Rastrigin

Rastrigin final

Forest

Forest final

Megacity (discrète)

Megacity final

Résultat final

10 paramètres (5 F)

50 paramètres (25 F)

1.000 paramètres (500 F)

10 paramètres (5 F)

50 paramètres (25 F)

1.000 paramètres (500 F)

10 paramètres (5 F)

50 paramètres (25 F)

1.000 paramètres (500 F)

ACOm

optimisation par colonies de fourmis M

0,37458

0,28208

0,17991

0,83657

1,00000

1,00000

1,00000

3,00000

1,00000

1,00000

0,10959

2,10959

100,000

COAm

algorithme d'optimisation coucou M

1,00000

0,73390

0,28892

2,02282

0,64504

0,34034

0,21362

1,19900

0,67153

0,34273

0,45422

1,46848

78,177

FAm

algorithme firefly M

0,64746

0,53292

0,18102

1,36140

0,55408

0,42299

0,64360

1,62067

0,21167

0,28416

1,00000

1,49583

74,486

BA

algorithme des chauves-souris

0,43859

1,00000

1,00000

2,43859

0,17768

0,17477

0,33595

0,68840

0,15329

0,07158

0,46287

0,68774

62,962

ABC

colonie d'abeilles artificielles

0,84599

0,51308

0,22588

1,58495

0,58850

0,21455

0,17249

0,97554

0,47444

0,26681

0,35941

1,10066

60,294

FSS

recherche d'un banc de poissons

0,64746

0,53292

0,18102

1,36140

0,55408

0,42299

0,64360

1,62067

0,21167

0,28416

1,00000

1,49583

21,475

PSO

optimisation par essaims de particules

0,22131

0,12861

0,05966

0,40958

0,15345

0,10486

0,28099

0,53930

0,08028

0,02385

0,00000

0,10413

14,971

RND

aléatoire

0,18210

0,15281

0,07011

0,40502

0,08623

0,04810

0,06094

0,19527

0,00000

0,00000

0,08904

0,08904

8,652

GWO

optimiseur du loup gris

0,00000

0,00000

0,00000

0,00000

0,00000

0,00000

0,00000

0,00000

0,18977

0,04119

0,01802

0,24898

1,000


Histogramme des résultats des tests de l'algorithme dans la figure 4

notes

Fig. 4 : Histogramme des résultats finaux des algorithmes de test

Conclusions sur les propriétés de l'algorithme Bat (BA) :

Avantages :
1. Grande vitesse.
2. L'algorithme fonctionne bien avec les fonctions lisses.
3. Évolutivité :

Inconvénients :
1. Trop de paramètres.
2. Résultats médiocres sur les fonctions discrètes.


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

Fichiers joints |
Télécharger ZIP
9_The_world_of_AO_gBAs.zip (68.81 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
Apprenez à concevoir un système de trading basé sur l’Accelerator Oscillator Apprenez à concevoir un système de trading basé sur l’Accelerator Oscillator
Un nouvel article de notre série sur la façon de créer des systèmes de trading simples à l'aide des indicateurs techniques les plus populaires. Nous découvrirons ensemble un nouvel indicateur : l’Accelerator Oscillator et nous apprendrons comment concevoir un système de trading en l'utilisant.
Algorithmes d'optimisation de la population : Algorithme des Lucioles (Firefly Algorithm - FA) Algorithmes d'optimisation de la population : Algorithme des Lucioles (Firefly Algorithm - FA)
Dans cet article, je considérerai la méthode d'optimisation de l'Algorithme Firefly (FA). Grâce à la modification, l'algorithme est passé d'un outsider à un véritable leader du classement.
Un exemple d'assemblage de modèles ONNX dans MQL5 Un exemple d'assemblage de modèles ONNX dans MQL5
ONNX (Open Neural Network eXchange) est un format ouvert conçu pour représenter les réseaux neuronaux. Dans cet article, nous allons montrer comment utiliser simultanément 2 modèles ONNX dans un Expert Advisor.
Comment utiliser les modèles ONNX dans MQL5 Comment utiliser les modèles ONNX dans MQL5
ONNX (Open Neural Network Exchange) est un format ouvert, conçu pour représenter des modèles d'apprentissage automatique. Dans cet article, nous verrons comment créer un modèle CNN-LSTM pour prévoir des séries temporelles financières. Nous montrerons également comment utiliser le modèle ONNX créé dans un Expert Advisor MQL5.