
Algoritmos de optimización de la población: Optimización del Lobo Gris (Grey Wolf Optimizer - GWO)
Contenido:
1. Introducción2. 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.
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.
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.
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;
En la expresión
//---------------------------------------------------------------------------- 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:
- 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.
- 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.
- El mínimo global deberá ubicarse en el centro de las coordenadas. Con ello pretendemos evitar las situaciones descritas en el punto 2.
- 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.
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.
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.
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
GWO en la función de prueba Skin.
GWO en la función de prueba Forest.
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) | |||
ant colony optimization | 0,98229 | 0,79108 | 0,12602 | 1,00000 | 0,62077 | 0,11521 | 0,38333 | 0,44000 | 0,02377 | 0,49805222 | |
artificial bee colony M | 1,00000 | 0,63922 | 0,08076 | 0,99908 | 0,20112 | 0,03785 | 1,00000 | 0,16333 | 0,02823 | 0,46106556 | |
artificial bee colony | 0,99339 | 0,73381 | 0,11118 | 0,99934 | 0,21437 | 0,04215 | 0,85000 | 0,16833 | 0,03130 | 0,46043000 | |
grey wolf optimizer | 0,99900 | 0,48033 | 0,18924 | 0,83844 | 0,08755 | 0,02555 | 1,00000 | 0,10000 | 0,02187 | 0,41577556 | |
particle swarm optimisation | 0,99627 | 0,38080 | 0,05089 | 0,93772 | 0,14540 | 0,04856 | 1,00000 | 0,09333 | 0,02233 | 0,40836667 | |
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





- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso