Algoritmo de Tribu Artificial (Artificial Tribe Algorithm, ATA)
162
0
Contenido
Introducción
Con el rápido avance de la tecnología en los últimos tiempos y la complejidad cada vez mayor de los problemas de optimización, los investigadores siguen buscando inspiración en la naturaleza. Un ejemplo destacado de este enfoque es el Algoritmo de Tribu Artificial (ATA) creado por los científicos T. Chen, Y. Wang y Q. Li y publicado en 2012. Inspirado en el comportamiento tribal, el ATA utiliza dos mecanismos principales -propagación y migración- que le permiten adaptarse a condiciones cambiantes y encontrar soluciones óptimas a una amplia variedad de retos. Imagine una vasta extensión de terreno en la que grupos de personas, como sus lejanos antepasados, se agrupan en busca de mejores recursos. Migran, comparten conocimientos y experiencia, y crean estrategias únicas para resolver problemas complejos. Este comportamiento constituyó la base para la creación de ATA, un algoritmo que armoniza dos mecanismos clave: la propagación y la migración.
El algoritmo ATA es un método de optimización completamente nuevo basado en los principios de los algoritmos inteligentes biónicos, que modela el comportamiento de las tribus naturales, utilizando sus capacidades de reproducción y migración para alcanzar soluciones óptimas. En este algoritmo, la tribu está formada por individuos que interactúan entre ellos para encontrar el óptimo global.
Implementación del algoritmo
El proceso de funcionamiento del algoritmo ATA comienza con la parametrización y la inicialización aleatoria de la tribu, tras lo cual se calcula el valor de adaptabilidad. A continuación, se incrementa el recuento de iteraciones y se valora la situación actual de la tribu. Si la situación es favorable (la diferencia en el valor óptimo de adaptabilidad entre generaciones es superior a un criterio determinado), se ejecutará un comportamiento de reproducción, en el que los individuos intercambiarán información. En caso contrario, se recurrirá al comportamiento migratorio, en el que los individuos se desplazan en función de la experiencia del individuo y de toda la tribu. La migración no puede realizarse de forma continua para evitar una dispersión excesiva. A continuación, se calcula nuevamente el valor de adaptabilidad y se compara con los mejores valores registrados para la tribu y cada individuo. Si se encuentra una solución mejor, se almacenará en la memoria. Luego se comprueba si se cumplen las condiciones de finalización y, si se cumplen, se finalizará la iteración. En caso contrario, el proceso volverá a la etapa de evaluación de la situación.
La incorporación de información global al ATA da peso a la experiencia histórica de la tribu para ayudar a encontrar mejores soluciones y mejorar la capacidad de búsqueda. El aumento del peso de la experiencia de la tribu contribuye a la eficacia del algoritmo al acelerar la convergencia. Para ello, el ATA introduce un peso de inercia global que mejora la capacidad de búsqueda y acelera el proceso.
La principal innovación del ATA es la presencia de un sistema de comportamiento dual que se adapta según la situación: la reproducción se utiliza para la exploración en profundidad cuando el progreso es bueno, mientras que la migración se activa cuando se ha atascado en óptimos locales, lo que promueve una exploración más profunda. También resulta importante la combinación de aprendizaje personalizado y social. La memoria individual (Xs) se usa en la migración, mientras que la memoria global (Xg) se pondera usando el factor de inercia AT_w. Al reproducirse, las parejas se eligen aleatoriamente para ayudar a mejorar la diversidad y acelerar la búsqueda.
El sistema de parámetros de ATA es simple pero eficaz. Controla el tamaño de la población (tribe_size), el criterio de cambio de comportamiento (AT_criterion) y el impacto global de la búsqueda (AT_w), lo cual convierte al algoritmo en una herramienta flexible y potente que compite fácilmente, como afirman los autores, con algoritmos más complejos, especialmente cuando se trata de tamaños de población pequeños.
Los principales componentes del algoritmo incluyen el comportamiento reproductivo, que se aplica a buen ritmo cuando la diferencia de adaptabilidad es mayor que el criterio establecido. En este caso, los individuos intercambiarán información parcial. El comportamiento migratorio se usa en una mala situación cuando la diferencia de adaptabilidad es pequeña, e implica un movimiento basado en la experiencia individual y global, considerando el peso de la inercia para potenciar la búsqueda global. El criterio de existencia evalúa los cambios en la mejor adaptabilidad entre iteraciones: si los cambios son grandes, se recurrirá a la reproducción, si los cambios son pequeños, se producirá la migración.
El algoritmo también incluye un sistema de actualización de la memoria que mantiene un registro de las mejores posiciones tanto de los individuos como de la tribu al completo. Estas posiciones se actualizarán cuando se encuentren nuevas soluciones mejores.
Las características del diseño del ATA incluyen parámetros sencillos, la integración del aprendizaje individual y social, así como el cambio autoadaptativo entre reproducción y migración. El peso de inercia global mejora la capacidad de búsqueda, acelerando la búsqueda de soluciones óptimas.
Así pues, las normas de comportamiento individual pueden describirse de la forma que sigue:
1. Dispersión. El individuo usa la información de la población para formar el material genético de las generaciones futuras. Si la situación del entorno existente es favorable, un individuo seleccionará al azar a otro individuo de la tribu y se cruzarán para regenerar la siguiente generación mediante el intercambio de información genética.
2. Migración. Si la situación existente es mala (esto indica que la diferencia intergeneracional en el valor óptimo de adaptabilidad es inferior al criterio existente), el individuo se desplazará según su experiencia histórica y la de la tribu, para realizar la migración tribal.
De forma esquemática, las fases clave que tienen lugar en la población del algoritmo pueden visualizarse en la figura 1.
Figura 1. Fases del movimiento de los individuos en la población del algoritmo ATA
Vamos a escribir el pseudocódigo del algoritmo ATA:
// Parámetros básicos:
// tribe_size - tamaño de la población de la tribu
// ATA_criterion - valor umbral del criterio de existencia
// ATA_w - peso global de inercia
// X - vector de posición del individuo
// Xs - mejor posición histórica del individuo
// Xg - mejor posición histórica global de la tribu
Algoritmo ATA:
Inicialización:
Creamos una tribu de tribe_size individuos con posiciones X aleatorias
Calculamos los valores iniciales de aptitud de todos los individuos
Inicializamos Xs y Xg con las mejores posiciones encontradas
iteración = 0
Hasta (iteración < max_iteraciones):
iteración = iteración + 1
// Comprobamos si la situación es favorable para la existencia
diferencia = | mejor_aptitud_actual - mejor_aptitud_anterior|
Si (diferencia > ATA_criterion):
// Es una buena situación para llevar a cabo el comportamiento reproductivo
Para cada individuo i:
// Selecciona un compañero j al azar de la tribu
j = aleatorio (1, tamaño_tribu) donde j ≠ i
// Fórmulas de reproducción:
r1 = aleatorio (0,1)
Yi+1 = r1 * Yj + (1 - r1) * Xi // Nueva posición del compañero
Xi+1 = r1 * Xi + (1- r1) * Yi // Nueva posición del individuo
De lo contrario:
// Es una mala situación para efectuar el comportamiento de migración
Para cada individuo i:
// Fórmula de migración:
r1 = aleatorio (0,1)
r2 = aleatorio (0,1)
Xi+1 = Xi + r1 * (Xs - Xi) + ATA_w * r2 * (Xg - Xi)
// Actualizamos los valores de aptitud y las mejores posiciones
Para cada individuo i:
Calculamos nueva_aptitud de Xi
Si nueva_aptitud es mejor que la mejor_aptitud_de_la_especie:
Actualizamos Xs para el individuo i
Si nueva_aptitud es mejor que mejor_aptitud_global:
Actualización de Xg
Guardamos mejor_aptitud_actual para la siguiente iteración
Retornamos Xg como la mejor solución encontrada
Figura 2. Esquema lógico del funcionamiento del algoritmo ATA
Definimos la clase C_AO_ATA, que implementa el algoritmo ATA. Describimos brevemente su contenido:
Herencia y miembros principales:- La clase se hereda de la clase básica C_AO
- Contendrá un destructor y un constructor
- popSize = 50 (tamaño de la tribu)
- AT_criterion = 0.3 (criterio de circunstancias adecuadas)
- AT_w = 1.46 (peso inercial)
- SetParams () - establecimiento de los parámetros del array "params"
- Init () - inicialización con los rangos de búsqueda
- Moving () - realización del movimiento de los individuos
- Revision () - evaluación y actualización de las soluciones
- prevBestFitness - almacena el mejor valor anterior para compararlo
Este es el marco básico del algoritmo, donde se definen todos los parámetros y métodos necesarios para su funcionamiento.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_ATA : public C_AO { public: //-------------------------------------------------------------------- ~C_AO_ATA () { } C_AO_ATA () { ao_name = "ATA"; ao_desc = "Artificial Tribe Algorithm"; ao_link = "https://www.mql5.com/es/articles/16588"; popSize = 50; // Population size AT_criterion = 0.3; // Criteria for assessing the current situation AT_w = 1.46; // Global inertial weight ArrayResize (params, 3); // Initialize parameters params [0].name = "popSize"; params [0].val = popSize; params [1].name = "AT_criterion"; params [1].val = AT_criterion; params [2].name = "AT_w"; params [2].val = AT_w; } void SetParams () // Method for setting parameters { popSize = (int)params [0].val; AT_criterion = params [1].val; AT_w = params [2].val; } bool Init (const double &rangeMinP [], // Minimum search range const double &rangeMaxP [], // Maximum search range const double &rangeStepP [], // Search step const int epochsP = 0); // Number of epochs void Moving (); // Moving method void Revision (); // Revision method //---------------------------------------------------------------------------- double AT_criterion; // Criteria for assessing the current situation double AT_w; // Global inertial weight private: //------------------------------------------------------------------- double prevBestFitness; // Previous best solution }; //——————————————————————————————————————————————————————————————————————————————
El método "Init" de la clase C_AO_ATA es responsable de inicializar el algoritmo. Vamos a desglosarlo por partes:
Parámetros del método:- rangeMinP [] - array de valores mínimos para cada dimensionalidad de búsqueda
- rangeMaxP [] - array de valores máximos
- rangeStepP [] - array de pasos de discretización
- epochsP - número de épocas (por defecto 0)
- Llamamos a "StandardInit" desde la clase básica para inicializar los parámetros estándar
- Si "StandardInit" retorna "false", el método se cancelará
- Establecemos "prevBestFitness" en "-DBL_MAX" (para la tarea de maximización)
- true en caso de inicialización correcta
- false si falla la inicialización estándar
Esta es la implementación mínima de la inicialización que prepara el algoritmo para su funcionamiento.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_ATA::Init (const double &rangeMinP [], // Minimum search range const double &rangeMaxP [], // Maximum search range const double &rangeStepP [], // Search step const int epochsP = 0) // Number of epochs { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; // Initialization of standard parameters //---------------------------------------------------------------------------- prevBestFitness = -DBL_MAX; return true; } //——————————————————————————————————————————————————————————————————————————————
El método "Moving ()" se encarga de desplazar a los individuos de la tribu y consta de dos partes principales:
Si se trata de la primera ejecución (revision = false):- Coloca aleatoriamente a todos los individuos en el espacio de búsqueda
- convierte sus posiciones en valores discretos admisibles
- marca que la colocación inicial está completa (revision = true)
- cada individuo selecciona una pareja al azar
- comparten información sobre sus posiciones
- forman nuevas posiciones basadas en este intercambio
- su mejor posición
- la mejor posición global
- el peso de inercia "AT_w"
Para todos los movimientos, se comprueban todas las nuevas posiciones y se convierten en valores admisibles dentro de los márgenes especificados. Además, cabe señalar el siguiente matiz, dado que el criterio de evaluación de la situación supone un parámetro externo y adimensional, deberemos normalizar la diferencia entre la mejor aptitud actual y la anterior según la diferencia entre la mejor aptitud histórica y la peor: diff = (fB - prevBestFitness) / (fB - fW). Para ello, este algoritmo monitorea no solo la mejor solución global, sino también la peor solución global.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ATA::Moving () { // Initial random positioning if (!revision) // If there has not been a revision yet { for (int i = 0; i < popSize; i++) // For each particle { for (int c = 0; c < coords; c++) // For each coordinate { a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); // Generate random position a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); // Convert to discrete values } } revision = true; // Set revision flag return; // Exit the method } //---------------------------------------------------------------------------- // Check the existence criterion double diff = (fB - prevBestFitness) / (fB - fW); double Xi = 0.0; double Xi_1 = 0.0; double Yi = 0.0; double Yi_1 = 0.0; double Xs = 0.0; double Xg = 0.0; int p = 0; double r1 = 0.0; double r2 = 0.0; if (diff > AT_criterion) { // Spread behavior (good situation) for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { p = u.RNDminusOne (popSize); r1 = u.RNDprobab (); Xi = a [i].cP [c]; Yi = a [p].cP [c]; Xi_1 = r1 * Xi + (1.0 - r1) * Yi; Yi_1 = r1 * Yi + (1.0 - r1) * Xi; a [i].c [c] = u.SeInDiSp (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]); a [p].c [c] = u.SeInDiSp (Yi_1, rangeMin [c], rangeMax [c], rangeStep [c]); } } } else { // Migration behavior (bad situation) for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { r1 = u.RNDprobab (); r2 = u.RNDprobab (); Xi = a [i].cP [c]; Xs = a [i].cB [c]; Xg = cB [c]; Xi_1 = Xi + r1 * (Xs - Xi) + AT_w * r2 * (Xg - Xi); a [i].c [c] = u.SeInDiSp (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]); } } } } //——————————————————————————————————————————————————————————————————————————————
El método "Revision ()" se encarga de evaluar y actualizar las mejores soluciones después de que se hayan desplazado los individuos. Esto es lo que hace:
Para todos los individuos de la tribu:- comprueba si la mejor solución global (fB) ha sido mejorada
- actualiza la peor solución encontrada (fW)
- comprueba y actualiza la mejor solución personal de cada individuo (a [i].fB)
- guarda las posiciones actuales como posiciones anteriores (en cP)
- guarda el mejor valor anterior (prevBestFitness = tempB)
- copia las coordenadas del mejor individuo en la mejor solución global (cB)
En esencia, se trata de un método de "revisión" del estado actual de la tribu, en el que se actualizan todas las métricas importantes (los mejores/peores valores globales, los mejores valores personales de cada individuo) y se almacenan la historia de posiciones.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ATA::Revision () { //---------------------------------------------------------------------------- int indB = -1; // Best particle index double tempB = fB; for (int i = 0; i < popSize; i++) // For each particle { if (a [i].f > fB) // If the function value is better than the current best one { fB = a [i].f; // Update the best value of the function indB = i; // Save the index of the best particle } if (a [i].f < fW) // If the function value is worse than the current worst one { fW = a [i].f; // Update the worst value of the function } if (a [i].f > a [i].fB) { a [i].fB = a [i].f; ArrayCopy (a [i].cB, a [i].c, 0, 0, WHOLE_ARRAY); } ArrayCopy (a [i].cP, a [i].c, 0, 0, WHOLE_ARRAY); } if (indB != -1) { prevBestFitness = tempB; ArrayCopy (cB, a [indB].c, 0, 0, WHOLE_ARRAY); // Copy the coordinates of the best particle } } //——————————————————————————————————————————————————————————————————————————————
Pasemos ahora a los resultados de las pruebas del algoritmo ATA en el banco de pruebas.
ATA|Artificial Tribe Algorithm|50.0|0.3|0.5|
=============================
5 Hilly's; Func runs: 10000; result: 0.540711768815426
25 Hilly's; Func runs: 10000; result: 0.31409437631469717
500 Hilly's; Func runs: 10000; result: 0.2512638813618161
=============================
5 Forest's; Func runs: 10000; result: 0.40309649266442193
25 Forest's; Func runs: 10000; result: 0.2572536671383149
500 Forest's; Func runs: 10000; result: 0.18349902023635473
=============================
5 Megacity's; Func runs: 10000; result: 0.24
25 Megacity's; Func runs: 10000; result: 0.13600000000000004
500 Megacity's; Func runs: 10000; result: 0.09518461538461616
=============================
All score: 2.42110 (26.90%)
Como podemos ver por la impresión de los resultados del algoritmo y la visualización, desafortunadamente, con estas tasas el algoritmo es incapaz de entrar en nuestra tabla de clasificación. La siguiente visualización muestra la escasa capacidad del algoritmo para salir de las trampas locales en las que se atasca el ATA. El algoritmo carece claramente de diversidad en la población de soluciones, lo cual provoca su degeneración.
ATAm en la función de prueba Hilly
Vamos a intentar mejorar el algoritmo ATA centrándonos en la falta de diversidad de soluciones en la población. Se trata de un aspecto importante, ya que la diversidad resulta clave para realizar una búsqueda eficaz en el espacio de soluciones. En nuestra modificación, introduciremos una probabilidad dinámica que dependerá del estado de adaptabilidad de la población.
Cuando la población se comprime en un rango estrecho del espacio de soluciones, puede provocar que el algoritmo se atasque en un óptimo local. Al igual que en la versión original del algoritmo, monitorearemos la diferencia entre la mejor solución global actual y la anterior, pero al mismo tiempo, si esta diferencia resulta demasiado pequeña, esto supondrá una señal de que la población no es lo suficientemente diversa y posiblemente se aproxime al colapso de la solución.
Para evitar esta situación, descartaremos los individuos que se encuentren con una cierta probabilidad lejos de la solución global actual. Esto tendrá lugar dentro de los límites aceptables de la tarea, lo cual garantizará que se cumplan las condiciones de la misma y evitará que se sobrepasen sus límites. Para determinar a qué distancia de la solución global actual estarán los individuos descartados, utilizaremos una distribución normal.
Curiosamente, cuanto mayor sea la diferencia entre la mejor solución actual y la anterior (etiquetada como "diff"), mayor será la probabilidad de que se produzcan estos valores atípicos. Esto nos permitirá responder de forma adaptativa al estado de la población: cuando empiece a atascarse, nos mostraremos más activos en la fase de migración, lo que a su vez aumentará las posibilidades de salir del óptimo local y encontrar mejores soluciones.
De esta manera, nuestra modificación del algoritmo ATA no solo ayudará a mantener la diversidad de soluciones, sino que también mejorará el rendimiento general de la búsqueda en el espacio de soluciones. Esto puede conducir a resultados más sostenibles y a una mayor calidad de las soluciones encontradas.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ATAm::Moving () { // Initial random positioning if (!revision) // If there has not been a revision yet { for (int i = 0; i < popSize; i++) // For each particle { for (int c = 0; c < coords; c++) // For each coordinate { a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); // Generate random position a [i].c [c] = u.SeInDiSp (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); // Convert to discrete values } } revision = true; // Set revision flag return; // Exit the method } //---------------------------------------------------------------------------- // Check the existence criterion double diff = (fB - prevBestFitness) / (fB - fW); double Xi = 0.0; double Xi_1 = 0.0; double Yi = 0.0; double Yi_1 = 0.0; double Xs = 0.0; double Xg = 0.0; int p = 0; double r1 = 0.0; double r2 = 0.0; if (diff > AT_criterion) { // Spread behavior (good situation) for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { p = u.RNDminusOne (popSize); r1 = u.RNDprobab (); Xi = a [i].cP [c]; Yi = a [p].cP [c]; Xi_1 = r1 * Xi + (1.0 - r1) * Yi; Yi_1 = r1 * Yi + (1.0 - r1) * Xi; a [i].c [c] = u.SeInDiSp (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]); a [p].c [c] = u.SeInDiSp (Yi_1, rangeMin [c], rangeMax [c], rangeStep [c]); } } } else { // Migration behavior (bad situation) for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { if (u.RNDprobab () < diff) { Xi_1 = u.GaussDistribution (cB [c], rangeMin [c], rangeMax [c], 1); a [i].c [c] = u.SeInDiSp (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]); } else { r1 = u.RNDprobab (); r2 = u.RNDprobab (); Xi = a [i].cP [c]; Xs = a [i].cB [c]; Xg = cB [c]; Xi_1 = Xi + r1 * (Xs - Xi) + AT_w * r2 * (Xg - Xi); a [i].c [c] = u.SeInDiSp (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]); } } } } } //——————————————————————————————————————————————————————————————————————————————
Resultados de las pruebas
Resultados de la versión modificada del algoritmo ATAm:
ATAm|Artificial Tribe Algorithm M|50.0|0.9|0.8|
=============================
5 Hilly's; Func runs: 10000; result: 0.7177133636761123
25 Hilly's; Func runs: 10000; result: 0.553035897955171
500 Hilly's; Func runs: 10000; result: 0.25234636879284034
=============================
5 Forest's; Func runs: 10000; result: 0.8249072382287125
25 Forest's; Func runs: 10000; result: 0.5590392181296365
500 Forest's; Func runs: 10000; result: 0.2047284499286112
=============================
5 Megacity's; Func runs: 10000; result: 0.43999999999999995
25 Megacity's; Func runs: 10000; result: 0.18615384615384617
500 Megacity's; Func runs: 10000; result: 0.09410769230769304
=============================
All score: 3.83203 (42.58%)
Esta vez los resultados han sido mucho más prometedores y ya merecen figurar en la tabla de clasificación, que desplazará a otro outsider. La visualización muestra un movimiento mucho más activo de los individuos de la población a través del espacio de decisiones. Sin embargo, ha surgido un nuevo problema: existe una dispersión significativa de los resultados, y no ha sido posible evitar por completo quedarse atascado en los óptimos locales.
ATAm en la función de prueba Hilly
ATAm en la función de prueba de Forest
ATAm en la función de prueba Megacity
El algoritmo ATA se ha situado en el puesto 33 de la tabla de clasificación.
| # | AO | Description | Hilly | Hilly final | Forest | Forest final | Megacity (discrete) | Megacity final | Final result | % de MAX | ||||||
| 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | 10 p (5 F) | 50 p (25 F) | 1000 p (500 F) | ||||||||
| 1 | ANS | across neighbourhood search | 0.94948 | 0.84776 | 0.43857 | 2.23581 | 1.00000 | 0.92334 | 0.39988 | 2.32323 | 0.70923 | 0.63477 | 0.23091 | 1.57491 | 6.134 | 68.15 |
| 2 | CLA | code lock algorithm (joo) | 0.95345 | 0.87107 | 0.37590 | 2.20042 | 0.98942 | 0.91709 | 0.31642 | 2.22294 | 0.79692 | 0.69385 | 0.19303 | 1.68380 | 6.107 | 67.86 |
| 3 | AMOm | animal migration optimization M | 0.90358 | 0.84317 | 0.46284 | 2.20959 | 0.99001 | 0.92436 | 0.46598 | 2.38034 | 0.56769 | 0.59132 | 0.23773 | 1.39675 | 5.987 | 66.52 |
| 4 | (P+O)ES | (P+O) evolution strategies | 0.92256 | 0.88101 | 0.40021 | 2.20379 | 0.97750 | 0.87490 | 0.31945 | 2.17185 | 0.67385 | 0.62985 | 0.18634 | 1.49003 | 5.866 | 65.17 |
| 5 | CTA | comet tail algorithm (joo) | 0.95346 | 0.86319 | 0.27770 | 2.09435 | 0.99794 | 0.85740 | 0.33949 | 2.19484 | 0.88769 | 0.56431 | 0.10512 | 1.55712 | 5.846 | 64.96 |
| 6 | SDSm | stochastic diffusion search M | 0.93066 | 0.85445 | 0.39476 | 2.17988 | 0.99983 | 0.89244 | 0.19619 | 2.08846 | 0.72333 | 0.61100 | 0.10670 | 1.44103 | 5.709 | 63.44 |
| 7 | AAm | archery algorithm M | 0.91744 | 0.70876 | 0.42160 | 2.04780 | 0.92527 | 0.75802 | 0.35328 | 2.03657 | 0.67385 | 0.55200 | 0.23738 | 1.46323 | 5.548 | 61.64 |
| 8 | ESG | evolution of social groups (joo) | 0.99906 | 0.79654 | 0.35056 | 2.14616 | 1.00000 | 0.82863 | 0.13102 | 1.95965 | 0.82333 | 0.55300 | 0.04725 | 1.42358 | 5.529 | 61.44 |
| 9 | SIA | simulated isotropic annealing (joo) | 0.95784 | 0.84264 | 0.41465 | 2.21513 | 0.98239 | 0.79586 | 0.20507 | 1.98332 | 0.68667 | 0.49300 | 0.09053 | 1.27020 | 5.469 | 60.76 |
| 10 | ACS | artificial cooperative search | 0.75547 | 0.74744 | 0.30407 | 1.80698 | 1.00000 | 0.88861 | 0.22413 | 2.11274 | 0.69077 | 0.48185 | 0.13322 | 1.30583 | 5.226 | 58.06 |
| 11 | ASO | anarchy society optimization | 0.84872 | 0.74646 | 0.31465 | 1.90983 | 0.96148 | 0.79150 | 0.23803 | 1.99101 | 0.57077 | 0.54062 | 0.16614 | 1.27752 | 5.178 | 57.54 |
| 12 | AOSm | búsqueda de orbitales atómicos M | 0.80232 | 0.70449 | 0.31021 | 1.81702 | 0.85660 | 0.69451 | 0.21996 | 1.77107 | 0.74615 | 0.52862 | 0.14358 | 1.41835 | 5.006 | 55.63 |
| 13 | TSEA | turtle shell evolution algorithm (joo) | 0.96798 | 0.64480 | 0.29672 | 1.90949 | 0.99449 | 0.61981 | 0.22708 | 1.84139 | 0.69077 | 0.42646 | 0.13598 | 1.25322 | 5.004 | 55.60 |
| 14 | DE | differential evolution | 0.95044 | 0.61674 | 0.30308 | 1.87026 | 0.95317 | 0.78896 | 0.16652 | 1.90865 | 0.78667 | 0.36033 | 0.02953 | 1.17653 | 4.955 | 55.06 |
| 15 | CRO | chemical reaction optimization | 0.94629 | 0.66112 | 0.29853 | 1.90593 | 0.87906 | 0.58422 | 0.21146 | 1.67473 | 0.75846 | 0.42646 | 0.12686 | 1.31178 | 4.892 | 54.36 |
| 16 | BSA | bird swarm algorithm | 0.89306 | 0.64900 | 0.26250 | 1.80455 | 0.92420 | 0.71121 | 0.24939 | 1.88479 | 0.69385 | 0.32615 | 0.10012 | 1.12012 | 4.809 | 53.44 |
| 17 | HS | harmony search | 0.86509 | 0.68782 | 0.32527 | 1.87818 | 0.99999 | 0.68002 | 0.09590 | 1.77592 | 0.62000 | 0.42267 | 0.05458 | 1.09725 | 4.751 | 52.79 |
| 18 | SSG | saplings sowing and growing | 0.77839 | 0.64925 | 0.39543 | 1.82308 | 0.85973 | 0.62467 | 0.17429 | 1.65869 | 0.64667 | 0.44133 | 0.10598 | 1.19398 | 4.676 | 51.95 |
| 19 | BCOm | bacterial chemotaxis optimization M | 0.75953 | 0.62268 | 0.31483 | 1.69704 | 0.89378 | 0.61339 | 0.22542 | 1.73259 | 0.65385 | 0.42092 | 0.14435 | 1.21912 | 4.649 | 51.65 |
| 20 | ABO | african buffalo optimization | 0.83337 | 0.62247 | 0.29964 | 1.75548 | 0.92170 | 0.58618 | 0.19723 | 1.70511 | 0.61000 | 0.43154 | 0.13225 | 1.17378 | 4.634 | 51.49 |
| 21 | (PO)ES | (PO) evolution strategies | 0.79025 | 0.62647 | 0.42935 | 1.84606 | 0.87616 | 0.60943 | 0.19591 | 1.68151 | 0.59000 | 0.37933 | 0.11322 | 1.08255 | 4.610 | 51.22 |
| 22 | TSm | tabu search M | 0.87795 | 0.61431 | 0.29104 | 1.78330 | 0.92885 | 0.51844 | 0.19054 | 1.63783 | 0.61077 | 0.38215 | 0.12157 | 1.11449 | 4.536 | 50.40 |
| 23 | BSO | brain storm optimization | 0.93736 | 0.57616 | 0.29688 | 1.81041 | 0.93131 | 0.55866 | 0.23537 | 1.72534 | 0.55231 | 0.29077 | 0.11914 | 0.96222 | 4.498 | 49.98 |
| 24 | WOAm | wale optimization algorithm M | 0.84521 | 0.56298 | 0.26263 | 1.67081 | 0.93100 | 0.52278 | 0.16365 | 1.61743 | 0.66308 | 0.41138 | 0.11357 | 1.18803 | 4.476 | 49.74 |
| 25 | AEFA | artificial electric field algorithm | 0.87700 | 0.61753 | 0.25235 | 1.74688 | 0.92729 | 0.72698 | 0.18064 | 1.83490 | 0.66615 | 0.11631 | 0.09508 | 0.87754 | 4.459 | 49.55 |
| 26 | AEO | artificial ecosystem-based optimization algorithm | 0.91380 | 0.46713 | 0.26470 | 1.64563 | 0.90223 | 0.43705 | 0.21400 | 1.55327 | 0.66154 | 0.30800 | 0.28563 | 1.25517 | 4.454 | 49.49 |
| 27 | ACOm | ant colony optimization M | 0.88190 | 0.66127 | 0.30377 | 1.84693 | 0.85873 | 0.58680 | 0.15051 | 1.59604 | 0.59667 | 0.37333 | 0.02472 | 0.99472 | 4.438 | 49.31 |
| 28 | BFO-GA | bacterial foraging optimization - ga | 0.89150 | 0.55111 | 0.31529 | 1.75790 | 0.96982 | 0.39612 | 0.06305 | 1.42899 | 0.72667 | 0.27500 | 0.03525 | 1.03692 | 4.224 | 46.93 |
| 29 | SOA | simple optimization algorithm | 0.91520 | 0.46976 | 0.27089 | 1.65585 | 0.89675 | 0.37401 | 0.16984 | 1.44060 | 0.69538 | 0.28031 | 0.10852 | 1.08422 | 4.181 | 46.45 |
| 30 | ABH | artificial bee hive algorithm | 0.84131 | 0.54227 | 0.26304 | 1.64663 | 0.87858 | 0.47779 | 0.17181 | 1.52818 | 0.50923 | 0.33877 | 0.10397 | 0.95197 | 4.127 | 45.85 |
| 31 | ACMO | atmospheric cloud model optimization | 0.90321 | 0.48546 | 0.30403 | 1.69270 | 0.80268 | 0.37857 | 0.19178 | 1.37303 | 0.62308 | 0.24400 | 0.10795 | 0.97503 | 4.041 | 44.90 |
| 32 | ADÁN | adaptive moment estimation M | 0.88635 | 0.44766 | 0.26613 | 1.60014 | 0.84497 | 0.38493 | 0.16889 | 1.39880 | 0.66154 | 0.27046 | 0.10594 | 1.03794 | 4.037 | 44.85 |
| 33 | ATAm | artificial tribe algorithm M | 0.71771 | 0.55304 | 0.25235 | 1.52310 | 0.82491 | 0.55904 | 0.20473 | 1.58867 | 0.44000 | 0.18615 | 0.09411 | 0.72026 | 3.832 | 42.58 |
| 34 | ASHA | artificial showering algorithm | 0.89686 | 0.40433 | 0.25617 | 1.55737 | 0.80360 | 0.35526 | 0.19160 | 1.35046 | 0.47692 | 0.18123 | 0.09774 | 0.75589 | 3.664 | 40.71 |
| 35 | ASBO | adaptive social behavior optimization | 0.76331 | 0.49253 | 0.32619 | 1.58202 | 0.79546 | 0.40035 | 0.26097 | 1.45677 | 0.26462 | 0.17169 | 0.18200 | 0.61831 | 3.657 | 40.63 |
| 36 | MEC | mind evolutionary computation | 0.69533 | 0.53376 | 0.32661 | 1.55569 | 0.72464 | 0.33036 | 0.07198 | 1.12698 | 0.52500 | 0.22000 | 0.04198 | 0.78698 | 3.470 | 38.55 |
| 37 | IWO | invasive weed optimization | 0.72679 | 0.52256 | 0.33123 | 1.58058 | 0.70756 | 0.33955 | 0.07484 | 1.12196 | 0.42333 | 0.23067 | 0.04617 | 0.70017 | 3.403 | 37.81 |
| 38 | Micro-AIS | micro artificial immune system | 0.79547 | 0.51922 | 0.30861 | 1.62330 | 0.72956 | 0.36879 | 0.09398 | 1.19233 | 0.37667 | 0.15867 | 0.02802 | 0.56335 | 3.379 | 37.54 |
| 39 | COAm | cuckoo optimization algorithm M | 0.75820 | 0.48652 | 0.31369 | 1.55841 | 0.74054 | 0.28051 | 0.05599 | 1.07704 | 0.50500 | 0.17467 | 0.03380 | 0.71347 | 3.349 | 37.21 |
| 40 | SDOm | spiral dynamics optimization M | 0.74601 | 0.44623 | 0.29687 | 1.48912 | 0.70204 | 0.34678 | 0.10944 | 1.15826 | 0.42833 | 0.16767 | 0.03663 | 0.63263 | 3.280 | 36.44 |
| 41 | NMm | Nelder-Mead method M | 0.73807 | 0.50598 | 0.31342 | 1.55747 | 0.63674 | 0.28302 | 0.08221 | 1.00197 | 0.44667 | 0.18667 | 0.04028 | 0.67362 | 3.233 | 35.92 |
| 42 | FAm | firefly algorithm M | 0.58634 | 0.47228 | 0.32276 | 1.38138 | 0.68467 | 0.37439 | 0.10908 | 1.16814 | 0.28667 | 0.16467 | 0.04722 | 0.49855 | 3.048 | 33.87 |
| 43 | GSA | gravitational search algorithm | 0.64757 | 0.49197 | 0.30062 | 1.44016 | 0.53962 | 0.36353 | 0.09945 | 1.00260 | 0.32667 | 0.12200 | 0.01917 | 0.46783 | 2.911 | 32.34 |
| 44 | BFO | bacterial foraging optimization | 0.61171 | 0.43270 | 0.31318 | 1.35759 | 0.54410 | 0.21511 | 0.05676 | 0.81597 | 0.42167 | 0.13800 | 0.03195 | 0.59162 | 2.765 | 30.72 |
| 45 | ABC | artificial bee colony | 0.63377 | 0.42402 | 0.30892 | 1.36671 | 0.55103 | 0.21874 | 0.05623 | 0.82600 | 0.34000 | 0.14200 | 0.03102 | 0.51302 | 2.706 | 30.06 |
Conclusiones
En este artículo, hemos examinado con detalle uno de los algoritmos de optimización más modernos: el algoritmo ATA. Aunque este algoritmo no funciona extremadamente bien en comparación con otros métodos, sí que realiza una valiosa contribución a nuestra comprensión de la gestión del estado dinámico de la población y de los métodos para analizar los problemas asociados con los óptimos locales.
El interés en el algoritmo ATA no se limita a sus dos fases principales, que en sí mismas tienen poco valor como métodos de solución. Mucho más importante es el enfoque que usa la selección dinámica de las fases de movimiento de los individuos y el control sobre el estado de la población. Es este aspecto el que nos permite adaptar con mayor eficacia el algoritmo a las condiciones cambiantes del problema y mejorar la calidad de las soluciones obtenidas. Por tanto, el estudio del ATA abre nuevos horizontes para futuras investigaciones en el campo de la optimización algorítmica y puede servir como base para el desarrollo de métodos más avanzados.
También estoy seguro de que al algoritmo discutido se pueden aplicar varios operadores, lo que aumentará significativamente su eficiencia. Por ejemplo, el uso de operadores de selección basados en la clasificación o el cruce puede mejorar sustancialmente los resultados.
Sin embargo, merece la pena señalar que la versión actual del algoritmo no tiene ninguna dependencia de la calidad de la solución y también carece de propiedades combinatorias, lo que limita sus capacidades. Todos estos aspectos suponen ámbitos interesantes para futuras investigaciones y mejoras, aunque quedan fuera del alcance de este artículo. Me alegraría mucho si alguno de los lectores decidiera experimentar con los cambios propuestos y compartir sus versiones del algoritmo en los comentarios.
Figura 3. Gradación por colores de los algoritmos según sus respectivas pruebas. Los resultados superiores o iguales a 0.99 se resaltan en blanco.
Figura 4. Histograma con los resultados de las pruebas de los algoritmos (en una escala de 0 a 100, cuanto más mejor, donde 100 es el máximo resultado teórico posible, el script para calcular la tabla de puntuación está en el archivo)
Ventajas y desventajas del algoritmo ATAm:
Ventajas:
- Pocos parámetros externos.
- Implementación sencilla.
- La idea de cambiar dinámicamente las estrategias de búsqueda resulta interesante.
Desventajas:
- Amplia dispersión de los resultados.
- Baja precisión de convergencia.
- Tendencia a atascarse.
Adjuntamos al artículo un archivo con las versiones actuales de los códigos de los algoritmos. El autor de este artículo no se responsabiliza de la exactitud absoluta de la descripción de los algoritmos canónicos, muchos de ellos han sido modificados para mejorar las capacidades de búsqueda. Las conclusiones y juicios presentados en los artículos se basan en los resultados de los experimentos realizados.
Programas usados en el artículo
| # | Nombre | Tipo | Descripción |
|---|---|---|---|
| 1 | #C_AO.mqh | Archivo de inclusión | Clase padre de algoritmos de optimización basados en la población |
| 2 | #C_AO_enum.mqh | Archivo de inclusión | Enumeración de los algoritmos de optimización basados en la población |
| 3 | TestFunctions.mqh | Archivo de inclusión | Biblioteca de funciones de prueba |
| 4 | TestStandFunctions.mqh | Archivo de inclusión | Biblioteca de funciones del banco de pruebas |
| 5 | Utilities.mqh | Archivo de inclusión | Biblioteca de funciones auxiliares |
| 6 | CalculationTestResults.mqh | Archivo de inclusión | Script para calcular los resultados en una tabla comparativa |
| 7 | Testing AOs.mq5 | Script | Banco de pruebas único para todos los algoritmos de optimización basados en la población |
| 8 | Simple use of population optimization algorithms.mq5 | Script | Ejemplo sencillo de utilización de algoritmos de optimización basados en la población sin visualización |
| 9 | Test_AO_ATAm.mq5 | Script | Banco de pruebas para ATAm |
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/16588
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.
Criterios de tendencia en el trading
Solicitudes en Connexus (Parte 6): Creación de una solicitud y respuesta HTTP
Ingeniería de características con Python y MQL5 (Parte I): Predicción de medias móviles para modelos de IA de largo plazo
Redes neuronales en el trading: Framework comercial híbrido con codificación predictiva (StockFormer)
- 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