MetaTrader 5 / Ejemplos
English Русский 中文 Deutsch 日本語 Português 한국어 Français Italiano Türkçe
preview
Algoritmos de optimización de la población: Optimización del Lobo Gris (Grey Wolf Optimizer - GWO)

Algoritmos de optimización de la población: Optimización del Lobo Gris (Grey Wolf Optimizer - GWO)

MetaTrader 5 — Ejemplos | 17 marzo 2023, 10:01
751 0
Andrey Dik
Andrey Dik

Contenido:

1. Introducción
2. Descripción del algoritmo
3. Funciones de prueba
4. Resultados de las pruebas


1. Introducción

El algoritmo del lobo gris es un algoritmo metaheurístico de inteligencia de enjambre estocástico desarrollado en 2014. Su idea se basa en el modelo de caza de las manadas de lobos grises. Se distinguen cuatro tipos de lobo: alfa, beta, delta y omega. El lobo alfa tiene más "peso" en la toma de decisiones y la gestión de la manada. A continuación, vienen los lobos beta y luego los delta, que están subordinados a los alfa y tienen poder sobre el resto de los lobos. El lobo omega siempre se somete a los demás lobos dominantes.

En el modelo matemático de la jerarquía lobuna, el lobo Alfa-α se considera el lobo dominante de la manada, y los miembros de la misma deben obedecer sus órdenes. Los lobos beta-β subordinados ayudan al lobo alfa en la toma de decisiones y se consideran los mejores candidatos para el papel de alfa. Los lobos delta δ deben obedecer al alfa y al beta, pero dominan a los omega. Los lobos omega ω se consideran cabezas de turco en la manada; son los individuos menos importantes de la misma y solo se les permite comer al final. Alfa se considera la solución más favorable.

La segunda y tercera mejores soluciones serán beta y delta, respectivamente. Las demás soluciones se considerarán omegas. Se supone que a los lobos más adaptados (alfa, beta y delta), es decir, los más cercanos a la presa, se aproximarán los demás lobos. Después de cada aproximación, se determinará quién es alfa, beta y delta en esta fase, y luego los lobos se reordenarán de nuevo. La reorganización se realizará hasta que los lobos se reúnan en una manada, que será la dirección óptima para atacar con la mínima distancia.

En el transcurso del algoritmo, distinguiremos 3 etapas principales en las que los lobos buscan a su presa, la rodean y la atacan. Durante la búsqueda, se detectarán los lobos alfa, beta y delta más próximos a la presa. Los demás, obedeciendo al dominante, podrán empezar a rodear a la presa o seguir moviéndose arbitrariamente en busca de una opción mejor.


2. Descripción del algoritmo

La jerarquía de la manada se representa de forma esquemática en la figura 1.  Reparto de papeles entre los miembros de la manada, con el alfa desempeñando el papel dominante.

dominance

Figura 1. Jerarquía social en una manada de lobos.




Modelo matemático y algoritmo
Jerarquía social:

  • Mejor solución como lobo alfa (α).
  • Segunda mejor solución como lobo beta (β).
  • Tercera mejor solución como lobo delta (δ).
  • Otras posibles soluciones como lobos omega (ω).

Entorno minero: cuando ya disponemos de las mejores soluciones alfa, beta y delta, la actuación posterior dependerá de omega.



stages

Figura 2. Etapas de la caza: búsqueda, rodeo, ataque.


Todas las iteraciones del algoritmo se representarán en tres pasos: búsqueda, rodeo, ataque. Para ello, la versión canónica del algoritmo incluirá un coeficiente estimado a: este se introducirá para mejorar la convergencia del algoritmo, disminuyendo a cero en cada iteración. Mientras el coeficiente sea superior a 1, la inicialización de los lobos estará en curso. En esta fase, la posición de la presa será completamente desconocida, por lo que los lobos deberán estar distribuidos aleatoriamente.

Tras la etapa de "búsqueda", se determinará el valor de la función de aptitud y solo entonces podremos pasar a la etapa de "rodeo". En esta fase, el coeficiente a es mayor que 1, lo cual significa que alfa beta y delta se alejarán de sus posiciones anteriores, permitiendo así concretar la posición de la presa prevista. Cuando el coeficiente a se convierta en 1, comenzará la fase de "ataque" y el coeficiente tenderá a 0 hasta el final de las iteraciones. Esto lleva a los lobos a aproximarse a su presa, suponiendo que ya han encontrado su mejor posición. Sin embargo, si uno de los lobos descubre una solución mejor en esta fase, la posición de la presa se actualizará, así como la jerarquía de lobos, pero el coeficiente seguirá tendiendo a 0. El proceso de cambio de «a» se representará usando una función no lineal: los pasos se muestran esquemáticamente en la figura 2.

El comportamiento del lobo omega es constante a lo largo de las épocas y consiste en seguir en cada momento el centro geométrico entre las posiciones de los individuos dominantes. En la figura 3, alfa, beta y delta se desvían de su posición anterior en una dirección aleatoria en un radio indicado por los coeficientes, mientras que los omegas se mueven hacia el centro entre ellos; en este caso, no exactamente hacia el centro, sino con cierta probabilidad desviándose respecto a este dentro del radio. Los radios están determinados por el coeficiente a, que, como ya recordará, varía, obligando a los radios a disminuir proporcionalmente.




suraunding

Figura 3. Patrón de movimiento de omega en relación con alfa, beta y delta.


El pseudocódigo del algoritmo GWO será el siguiente:

1) Inicializamos aleatoriamente la población de lobos grises.
2) Calculamos la aptitud de cada miembro de la población.
3) Líderes de manada:
-α = miembro con el mejor valor de idoneidad
-β = segundo mejor integrante (en términos de idoneidad)
-δ = tercer mejor integrante (en términos de valor de aptitud)
Luego actualizaremos las posiciones de todos los lobos omega según las fórmulas que dependen de α, β, δ
4) Calculamos la idoneidad de cada miembro de la población.
5) Repetimos el paso 3.

Vamos a ver el código del algoritmo. La única adición que hemos hecho a la versión original es la posibilidad de establecer el número de lobos líderes de la manada. Ahora podremos establecer cualquier número de líderes, incluso toda la manada. Esto podría resultar útil para tareas específicas.

Comenzaremos, como de costumbre, por la unidad elemental del algoritmo, el lobo, que representa la solución del problema. Es una estructura compuesta por un array de coordenadas y un valor de presa (función de aptitud). La estructura será la misma para los líderes y los miembros secundarios de la manada. Esto simplificará el algoritmo y permitirá utilizar las mismas estructuras en las operaciones de ciclo, además de que los papeles de los lobos cambiarán repetidamente a lo largo de las iteraciones. Los roles se definen unívocamente según su posición en el array tras la clasificación: los líderes se hallarán al principio del array.

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

La manada de lobos estará representada por una clase compacta y comprensible. Aquí se declararán los rangos y pasos de los parámetros a optimizar, la mejor posición de la presa, el mejor valor de solución y las funciones auxiliares.

//——————————————————————————————————————————————————————————————————————————————
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
};
//——————————————————————————————————————————————————————————————————————————————

De forma tradicional, la declaración de la clase va seguida de una inicialización en la descripción del algoritmo. Aquí resetearemos al valor mínimo double de la aptitud de los lobos y distribuiremos el tamaño de las matrices.

//——————————————————————————————————————————————————————————————————————————————
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;
  }
}
//——————————————————————————————————————————————————————————————————————————————

El primer método abierto que se llama en cada iteración será el más difícil de entender y el más voluminoso. Aquí residirá la lógica básica del algoritmo; de hecho, la viabilidad del algoritmo estará garantizada por el mecanismo probabilístico descrito estrictamente por las fórmulas. Vamos a analizar este método paso a paso. En la primera iteración, cuando desconocemos la posición prevista de la presa, tras comprobar la bandera, enviaremos a los lobos en una dirección aleatoria, generando simplemente valores a partir de los máximos y mínimos de los parámetros optimizados.

//----------------------------------------------------------------------------
//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;
}

La versión canónica de la descripción del algoritmo contiene fórmulas que operan sobre vectores, pero resultan mucho más claras en forma de código. El cálculo de los lobos omega es anterior al cálculo de los lobos alfa, beta y delta, porque hay que usar los valores anteriores de los líderes.

El componente principal que proporciona las tres fases de la caza (búsqueda, rodeo, ataque) es el coeficiente a. Es una dependencia no lineal de la iteración actual y del número total de iteraciones, y tenderá a 0.
Los siguientes componentes de la ecuación son Ai y Сi:
  • Ai = 2.0 * a * r1 - a;
  • Ci = 2.0 * r2;
donde r1 y r2 son números aleatorios dentro del rango [0,0;1,0].
En la expresión
Xn += wolves [abd].c [c] - Ai * (Ci * wolves [abd].c [c] - wolves [w].c [c]);
las coordenadas de los lobos se ajustarán en función de los valores medios de los lobos líderes. Como en el algoritmo podremos fijar cualquier número de líderes, las coordenadas se sumarán en un ciclo. A continuación, dividiremos la suma obtenida por el número de líderes. Esta operación se realizará para cada coordenada por separado, generando cada vez un nuevo valor de r1 y r2. Como podemos ver, la nueva posición de los lobos omega se ajustará según la posición de los líderes considerando su propia posición actual.
//----------------------------------------------------------------------------
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]);
}

Aquí estará el cálculo de los líderes. Para ellos, también se calcularán los coeficientes a, Ai y Ci para cada coordenada. La única diferencia será que la posición de los líderes cambiará en relación con las mejores coordenadas de la presa del momento actual y su propia posición. Los líderes rodearán a su presa, acercándose y alejándose alternativamente, y controlando a los lobos secundarios al ataque.

//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]);
}

Este será el segundo método público llamado en cada iteración. Esto actualizará el estatus de los líderes de la manada, clasificando en la práctica a los lobos según su valor de adaptabilidad. Si se encuentran coordenadas de la presa mejores que las almacenadas en toda la manada, los valores se actualizarán. 

//——————————————————————————————————————————————————————————————————————————————
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. Funciones de prueba

En artículos anteriores ya nos hemos familiarizado con las funciones Skin, Forest y Megacity. Estas funciones de prueba cumplen todos los criterios de complejidad para probar algoritmos de optimización. No obstante, existe una característica que no hemos considerado y este punto deberá aplicarse para mejorar la objetividad de las pruebas. Los requisitos serán los siguientes:

  1. El extremo global no deberá encontrarse en los límites del intervalo. Si el algoritmo no tiene una comprobación de fuera de rango, podrían darse situaciones en las que el algoritmo muestre resultados excelentes. Esto se debe a que, a causa de un defecto interno, los valores se hallarán en los límites.
  2. El extremo global no deberá estar en el centro de las coordenadas del rango. En este caso, se considerará la situación cuando el algoritmo genera valores promediados sobre el intervalo.
  3. El mínimo global deberá ubicarse en el centro de las coordenadas. Con ello pretendemos evitar las situaciones descritas en el punto 2.
  4. El cálculo de los resultados de la función de prueba deberá considerar el momento en que los números generados aleatoriamente en todo el dominio de la función (cuando la función es multivariable) den un resultado medio de aproximadamente el 50% del máximo, aunque en la práctica estos resultados se generen aleatoriamente.

Teniendo en cuenta estos requisitos, hemos revisado los límites de las funciones de prueba y hemos desplazado los centros del rango a los mínimos de los valores de las funciones. Una vez más, debíamos hacer esto para obtener la mayor verosimilitud y objetividad en los resultados de las pruebas de los algoritmos de optimización. Por consiguiente, en las nuevas funciones de prueba, el algoritmo de optimización basado en la generación de números aleatorios ha mostrado un resultado global sistemáticamente bajo, lo cual se corresponde con la realidad. Encontrará la tabla de clasificación actualizada al final del artículo.

Función Skin. Es una función suavizada que se caracteriza por tener varios extremos locales capaces de confundir al algoritmo de optimización, que puede quedarse atascado en uno de ellos. El único extremo global se caracteriza por tener valores débilmente cambiantes en sus proximidades. Esta característica pone de relieve la capacidad del algoritmo para dividirse en zonas analizables en lugar de concentrarse en una sola. En particular, el algoritmo de colonia de abejas (ABC) se comporta de esta manera.

skin

Figura 4. Función de prueba Skin.

Función Forest. Es una función con varios extremos suavizados y varios extremos indiferenciados. Se trata de una prueba bastante eficaz para verificar si los algoritmos de optimización son capaces de encontrar una "aguja en un pajar", ya que hallar un único punto de máximo global es una tarea muy complicada, sobre todo si la función contiene muchas variables. En esta tarea, se distinguió especialmente por su comportamiento el algoritmo de colonia de hormigas ACO, que allanó el camino hacia el objetivo de una forma increíble.



forest

Figura 5. Función de prueba Forest.

Función Megacity. La función supone un problema de optimización discreto con un extremo global y varios extremos locales. Con una superficie a investigar extremadamente compleja, supone una buena prueba para los algoritmos que requieren un gradiente. Además, el "suelo", también llamado mínimo, resulta completamente plano y no ofrece ninguna información sobre la posible dirección hacia el máximo global.


megacity

Figura 6. Función de prueba Megacity.

Al código de las funciones de prueba le hemos añadido las comprobaciones de los argumentos de entrada que se encuentran fuera del rango. En la versión anterior de las funciones, los algoritmos de optimización no podían obtener de forma bastante justa los valores de la función superiores a los contenidos realmente por la función en su rango de definición.


4. Resultados de las pruebas

También hemos actualizado el banco de pruebas, debido a los cambios introducidos en las funciones de prueba. Los gráficos de convergencia de los algoritmos de optimización siguen siendo visibles en la parte derecha de la pantalla. La línea verde muestra los resultados de la convergencia en una función con dos variables. La línea azul corresponde a las funciones con 40 variables. La línea roja corresponde a las funciones con 1000 variables. El círculo negro de mayor tamaño indica la posición del máximo global de la función. El círculo negro de menor tamaño indica la posición del valor de la solución actual del algoritmo de optimización. El cruce de las líneas blancas indica el centro geométrico de las funciones de prueba y se corresponde con el mínimo global: hemos introducido esto para una mejor percepción visual del comportamiento de los algoritmos probados. Los puntos blancos representan las soluciones intermedias medias. Los puntos pequeños coloreados indican los pares de coordenadas de la dimensionalidad correspondiente; el color indica el orden de magnitud de la función de prueba.

En la tabla actualizada, podrá ver los resultados renovados de las pruebas de los algoritmos de optimización comentados en artículos anteriores, en el nuevo banco de pruebas. La línea sobre la velocidad de convergencia se ha eliminado de la tabla, ya que sobrecargaba innecesariamente la percepción de esta: ahora podemos determinar visualmente la velocidad a partir de la animación del banco de pruebas. Asimismo, hemos añadido una columna con la descripción del algoritmo.

Resultados de las pruebas 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's; Func runs 10000 result: 4.844203223078298
2022.11.28 12:17:06.382    Test_AO_ACO (EURUSD,M1)    Score: 0.98229
2022.11.28 12:17:14.191    Test_AO_ACO (EURUSD,M1)    20 Skin's; Func runs 10000 result: 4.043383610736287
2022.11.28 12:17:14.191    Test_AO_ACO (EURUSD,M1)    Score: 0.79108
2022.11.28 12:17:55.578    Test_AO_ACO (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.2580170651681026
2022.11.28 12:17:55.578    Test_AO_ACO (EURUSD,M1)    Score: 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's; Func runs 10000 result: 1.7678766100234538
2022.11.28 12:18:01.491    Test_AO_ACO (EURUSD,M1)    Score: 1.00000
2022.11.28 12:18:09.508    Test_AO_ACO (EURUSD,M1)    20 Forest's; Func runs 10000 result: 1.0974381500585855
2022.11.28 12:18:09.508    Test_AO_ACO (EURUSD,M1)    Score: 0.62077
2022.11.28 12:18:53.348    Test_AO_ACO (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.20367726028454042
2022.11.28 12:18:53.348    Test_AO_ACO (EURUSD,M1)    Score: 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's; Func runs 10000 result: 4.6
2022.11.28 12:18:59.303    Test_AO_ACO (EURUSD,M1)    Score: 0.38333
2022.11.28 12:19:07.598    Test_AO_ACO (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 5.28
2022.11.28 12:19:07.598    Test_AO_ACO (EURUSD,M1)    Score: 0.44000
2022.11.28 12:19:53.172    Test_AO_ACO (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.2852
2022.11.28 12:19:53.172    Test_AO_ACO (EURUSD,M1)    Score: 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)    All score for C_AO_ACOm: 0.4980520084646583

Resultados de las pruebas ABCm (Artificial Bee Colony):

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's; Func runs 10000 result: 4.918379986612587
2022.11.28 12:35:52.581    Test_AO_ABCm (EURUSD,M1)    Score: 1.00000
2022.11.28 12:35:59.454    Test_AO_ABCm (EURUSD,M1)    20 Skin's; Func runs 10000 result: 3.4073825805846374
2022.11.28 12:35:59.454    Test_AO_ABCm (EURUSD,M1)    Score: 0.63922
2022.11.28 12:36:32.428    Test_AO_ABCm (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.0684464927353337
2022.11.28 12:36:32.428    Test_AO_ABCm (EURUSD,M1)    Score: 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's; Func runs 10000 result: 1.766245456669898
2022.11.28 12:36:38.086    Test_AO_ABCm (EURUSD,M1)    Score: 0.99908
2022.11.28 12:36:45.326    Test_AO_ABCm (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.35556125136004335
2022.11.28 12:36:45.326    Test_AO_ABCm (EURUSD,M1)    Score: 0.20112
2022.11.28 12:37:22.301    Test_AO_ABCm (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.06691711149962026
2022.11.28 12:37:22.301    Test_AO_ABCm (EURUSD,M1)    Score: 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's; Func runs 10000 result: 12.0
2022.11.28 12:37:28.047    Test_AO_ABCm (EURUSD,M1)    Score: 1.00000
2022.11.28 12:37:35.689    Test_AO_ABCm (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 1.9600000000000002
2022.11.28 12:37:35.689    Test_AO_ABCm (EURUSD,M1)    Score: 0.16333
2022.11.28 12:38:11.609    Test_AO_ABCm (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.33880000000000005
2022.11.28 12:38:11.609    Test_AO_ABCm (EURUSD,M1)    Score: 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)    All score for C_AO_ABCm: 0.4610669021761763

Resultados de las pruebas ABC (Artificial Bee Colony):

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's; Func runs 10000 result: 4.890679983950205
2022.11.28 12:29:56.785    Test_AO_ABC (EURUSD,M1)    Score: 0.99339
2022.11.28 12:30:03.880    Test_AO_ABC (EURUSD,M1)    20 Skin's; Func runs 10000 result: 3.8035430744604133
2022.11.28 12:30:03.880    Test_AO_ABC (EURUSD,M1)    Score: 0.73381
2022.11.28 12:30:37.089    Test_AO_ABC (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.195840100227333
2022.11.28 12:30:37.089    Test_AO_ABC (EURUSD,M1)    Score: 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's; Func runs 10000 result: 1.7667070507449298
2022.11.28 12:30:42.811    Test_AO_ABC (EURUSD,M1)    Score: 0.99934
2022.11.28 12:30:50.108    Test_AO_ABC (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.3789854806095275
2022.11.28 12:30:50.108    Test_AO_ABC (EURUSD,M1)    Score: 0.21437
2022.11.28 12:31:25.900    Test_AO_ABC (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.07451308481273813
2022.11.28 12:31:25.900    Test_AO_ABC (EURUSD,M1)    Score: 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's; Func runs 10000 result: 10.2
2022.11.28 12:31:31.510    Test_AO_ABC (EURUSD,M1)    Score: 0.85000
2022.11.28 12:31:38.855    Test_AO_ABC (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 2.02
2022.11.28 12:31:38.855    Test_AO_ABC (EURUSD,M1)    Score: 0.16833
2022.11.28 12:32:14.623    Test_AO_ABC (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.37559999999999993
2022.11.28 12:32:14.623    Test_AO_ABC (EURUSD,M1)    Score: 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)    All score for C_AO_ABC: 0.46043003186219245

Resultados de las pruebas 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's; Func runs 10000 result: 4.90276049713715
2022.11.28 12:01:09.723    Test_AO_PSO (EURUSD,M1)    Score: 0.99627
2022.11.28 12:01:17.064    Test_AO_PSO (EURUSD,M1)    20 Skin's; Func runs 10000 result: 2.3250668562024566
2022.11.28 12:01:17.064    Test_AO_PSO (EURUSD,M1)    Score: 0.38080
2022.11.28 12:01:52.880    Test_AO_PSO (EURUSD,M1)    500 Skin's; Func runs 10000 result: 0.943331687769892
2022.11.28 12:01:52.881    Test_AO_PSO (EURUSD,M1)    Score: 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's; Func runs 10000 result: 1.6577769478566602
2022.11.28 12:01:58.492    Test_AO_PSO (EURUSD,M1)    Score: 0.93772
2022.11.28 12:02:06.105    Test_AO_PSO (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.25704414127018393
2022.11.28 12:02:06.105    Test_AO_PSO (EURUSD,M1)    Score: 0.14540
2022.11.28 12:02:44.566    Test_AO_PSO (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.08584805450831333
2022.11.28 12:02:44.566    Test_AO_PSO (EURUSD,M1)    Score: 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's; Func runs 10000 result: 12.0
2022.11.28 12:02:50.268    Test_AO_PSO (EURUSD,M1)    Score: 1.00000
2022.11.28 12:02:57.649    Test_AO_PSO (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 1.1199999999999999
2022.11.28 12:02:57.649    Test_AO_PSO (EURUSD,M1)    Score: 0.09333
2022.11.28 12:03:34.895    Test_AO_PSO (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.268
2022.11.28 12:03:34.895    Test_AO_PSO (EURUSD,M1)    Score: 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)    All score for C_AO_PSO: 0.40836715689743186

Resultados de las pruebas RND (Random):

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's; Func runs 10000 result: 4.915522750114194
2022.11.28 16:45:21.569    Test_AO_RND (EURUSD,M1)    Score: 0.99932
2022.11.28 16:45:28.607    Test_AO_RND (EURUSD,M1)    20 Skin's; Func runs 10000 result: 2.584546688199847
2022.11.28 16:45:28.607    Test_AO_RND (EURUSD,M1)    Score: 0.44276
2022.11.28 16:46:02.695    Test_AO_RND (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.0161336237263792
2022.11.28 16:46:02.695    Test_AO_RND (EURUSD,M1)    Score: 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's; Func runs 10000 result: 1.4695680943894533
2022.11.28 16:46:09.622    Test_AO_RND (EURUSD,M1)    Score: 0.83126
2022.11.28 16:46:17.675    Test_AO_RND (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.20373533112604475
2022.11.28 16:46:17.675    Test_AO_RND (EURUSD,M1)    Score: 0.11524
2022.11.28 16:46:54.544    Test_AO_RND (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.0538909816827325
2022.11.28 16:46:54.544    Test_AO_RND (EURUSD,M1)    Score: 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's; Func runs 10000 result: 10.0
2022.11.28 16:47:00.219    Test_AO_RND (EURUSD,M1)    Score: 0.83333
2022.11.28 16:47:08.145    Test_AO_RND (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 1.08
2022.11.28 16:47:08.145    Test_AO_RND (EURUSD,M1)    Score: 0.09000
2022.11.28 16:47:49.875    Test_AO_RND (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.28840000000000005
2022.11.28 16:47:49.875    Test_AO_RND (EURUSD,M1)    Score: 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)    All score for C_AO_RND: 0.38163317904126015



skin

  GWO en la función de prueba Skin.

forest

GWO en la función de prueba Forest.

megacity

  GWO en la función de prueba Megacity.

Resultados de las pruebas 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's; Func runs 10000 result: 4.914175888065222
2022.11.28 13:24:14.895    Test_AO_GWO (EURUSD,M1)    Score: 0.99900
2022.11.28 13:24:22.175    Test_AO_GWO (EURUSD,M1)    20 Skin's; Func runs 10000 result: 2.7419092435309405
2022.11.28 13:24:22.175    Test_AO_GWO (EURUSD,M1)    Score: 0.48033
2022.11.28 13:25:01.381    Test_AO_GWO (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.5227848592798188
2022.11.28 13:25:01.381    Test_AO_GWO (EURUSD,M1)    Score: 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's; Func runs 10000 result: 1.4822580151819842
2022.11.28 13:25:06.924    Test_AO_GWO (EURUSD,M1)    Score: 0.83844
2022.11.28 13:25:14.551    Test_AO_GWO (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.15477395149266915
2022.11.28 13:25:14.551    Test_AO_GWO (EURUSD,M1)    Score: 0.08755
2022.11.28 13:25:56.900    Test_AO_GWO (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.04517298232457319
2022.11.28 13:25:56.900    Test_AO_GWO (EURUSD,M1)    Score: 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's; Func runs 10000 result: 12.0
2022.11.28 13:26:02.305    Test_AO_GWO (EURUSD,M1)    Score: 1.00000
2022.11.28 13:26:09.475    Test_AO_GWO (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 1.2
2022.11.28 13:26:09.475    Test_AO_GWO (EURUSD,M1)    Score: 0.10000
2022.11.28 13:26:48.980    Test_AO_GWO (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.2624
2022.11.28 13:26:48.980    Test_AO_GWO (EURUSD,M1)    Score: 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)    All score for C_AO_GWO: 0.41577484361261224

El algoritmo de optimización del Lobo Gris, GWO, es uno de los recientes algoritmos de optimización bioinspirados basados en la simulación de la caza impulsada de una manada de lobos grises. Por término medio, el algoritmo ha funcionado muy bien en varios tipos de funciones, tanto en términos de precisión de la búsqueda de extremos como en la velocidad de convergencia. En algunas pruebas, muestra los mejores indicadores de la tabla de clasificación. El rendimiento básico del algoritmo de optimización del Lobo Gris es mejor que el del algoritmo de optimización del enjambre de partículas, que es el "clásico" en la clase de algoritmos de optimización bioinspirados.

La complejidad computacional del algoritmo de optimización del Lobo Gris es comparable a la de la optimización por enjambre de partículas. Debido a las numerosas ventajas del algoritmo de optimización GWO, se ha trabajado mucho en su modificación en el poco tiempo que ha pasado desde que se publicó por primera vez. El único inconveniente del algoritmo es la baja precisión de las coordenadas encontradas de la función con el máximo Forest agudo.

La baja precisión del extremo encontrado resulta evidente en todas las dimensiones de la función Forest, y los resultados son los peores entre todos los integrantes de la tabla. No obstante, en la función Skin suavizada, el algoritmo ha rendido admirablemente, siendo el líder, especialmente con la función Skin de gran dimensionalidad. El GWO también es el tercero de la tabla en alcanzar el 100% del máximo global en la función Megacity.

AO

Description

Skin

Forest

Megacity (discrete)

Final result

2 params (1 F)

40 params (20 F)

1000 params (500 F)

2 params (1 F)

40 params (20 F)

1000 params (500 F)

2 params (1 F)

40 params (20 F)

1000 params (500 F)

ACOm

ant colony optimization

0,98229

0,79108

0,12602

1,00000

0,62077

0,11521

0,38333

0,44000

0,02377

0,49805222

ABCm

artificial bee colony M

1,00000

0,63922

0,08076

0,99908

0,20112

0,03785

1,00000

0,16333

0,02823

0,46106556

ABC

artificial bee colony

0,99339

0,73381

0,11118

0,99934

0,21437

0,04215

0,85000

0,16833

0,03130

0,46043000

GWO

grey wolf optimizer

0,99900

0,48033

0,18924

0,83844

0,08755

0,02555

1,00000

0,10000

0,02187

0,41577556

PSO

particle swarm optimisation

0,99627

0,38080

0,05089

0,93772

0,14540

0,04856

1,00000

0,09333

0,02233

0,40836667

RND

random

0,99932

0,44276

0,06827

0,83126

0,11524

0,03048

0,83333

0,09000

0,02403

0,38163222


Conclusiones:

Ventajas:
1. Es rápido.
2. Muestra una alta convergencia para funciones suaves con un gran número de variables.

Desventajas:
1. No es universal.
2. Se queda atascado en los extremos locales.
3. Tiene baja escalabilidad en funciones discretas e indiferenciadas.


Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/11785

Archivos adjuntos |
Descargar ZIP
l5_The_world_of_AO_oGWOv.zip (44.97 KB)
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores
DoEasy. Elementos de control (Parte 28): Estilos de barra en el control «ProgressBar» DoEasy. Elementos de control (Parte 28): Estilos de barra en el control «ProgressBar»
El artículo desarrollará los estilos de visualización y el texto de descripción para la barra de progreso del control ProgressBar.
Redes neuronales: así de sencillo (Parte 34): Función cuantílica totalmente parametrizada Redes neuronales: así de sencillo (Parte 34): Función cuantílica totalmente parametrizada
Seguimos analizando algoritmos de aprendizaje Q distribuidos. En artículos anteriores hemos analizado los algoritmos de aprendizaje Q distribuido y cuantílico. En el primero, enseñamos las probabilidades de los rangos de valores dados. En el segundo, enseñamos los rangos con una probabilidad determinada. Tanto en el primer algoritmo como en el segundo, usamos el conocimiento a priori de una distribución y enseñamos la otra. En el presente artículo, veremos un algoritmo que permite al modelo aprender ambas distribuciones.
Algoritmos de optimización de la población: Algoritmo de optimización de cuco (Cuckoo Optimization Algorithm — COA) Algoritmos de optimización de la población: Algoritmo de optimización de cuco (Cuckoo Optimization Algorithm — COA)
El siguiente algoritmo que analizaremos será la optimización de la búsqueda de cuco usando los vuelos de Levy. Este es uno de los últimos algoritmos de optimización, así como el nuevo líder en la clasificación.
Algoritmos de optimización de la población: Colonia de abejas artificiales (Artificial Bee Colony - ABC) Algoritmos de optimización de la población: Colonia de abejas artificiales (Artificial Bee Colony - ABC)
Hoy estudiaremos el algoritmo de colonia de abejas artificiales. Asimismo, complementaremos nuestros conocimientos con nuevos principios para el estudio de los espacios funcionales. En este artículo hablaremos sobre mi interpretación de la versión clásica del algoritmo.