Algoritmo de colmena artificial — Artificial Bee Hive Algorithm (ABHA): Pruebas y resultados
243
0
1. Introducción
En el artículo anterior, profundizamos en el fascinante mundo del algoritmo de colmena artificial ABHA, analizando detalladamente su funcionamiento. No solo describiremos la estructura y la clase, sino que también presentaremos el pseudocódigo del algoritmo y también consideraremos con detalle los métodos "Moving" y "Revision". Esta introducción formará la base para un mayor estudio y comprensión del algoritmo.
En el presente artículo continuaremos desarrollando este tema, profundizando en la codificación y abarcando todos los métodos restantes. Como siempre, realizaremos las pruebas con varias funciones de prueba para evaluar la eficiencia y el rendimiento del algoritmo. Para concluir, resumiremos los resultados del trabajo del algoritmo en una tabla de calificación.
Vamos a recordar los puntos principales del algoritmo ABHA, basado en el modelo del estado y comportamiento individual de las abejas:
- Cada abeja está representada como un agente individual cuyo comportamiento está regulado por estados (novato, experimentado, explorador, explotador).
- En un momento dado, el comportamiento de una sola abeja está determinado por la información interna y externa de que dispone, así como por su estado motivacional, según un conjunto de reglas específicas.
- El conjunto de reglas será el mismo para cada abeja, pero como el entorno percibido difiere para las abejas en diferentes ubicaciones espaciales, su comportamiento también será distinto.
- Las abejas pueden mostrar diferentes comportamientos dependiendo de su experiencia de búsqueda de alimento y/o su estado motivacional.
Así, el modelo ABHA representa el comportamiento de las abejas como regulado por un conjunto de reglas que se adaptan a las características individuales y al entorno.
2. Continuamos la implementación del algoritmo
Vamos a seguir escribiendo los métodos de algoritmo utilizando nuestro pseudocódigo descrito en el artículo anterior. Comencemos.
El método "StageActivityNovice" controla cómo los novatos cambian sus posiciones basándose en búsquedas aleatorias o siguiendo la "danza" de otros agentes. Descripción del método:
- Parámetros: el método toma una referencia a un objeto "agent" de tipo "S_ABHA_Agent", que representa al "novato" en el algoritmo.
- Valor de retorno: el método no retornará nada (void).
Lógica del método:
1. Se declara una variable "val" para almacenar las coordenadas actuales del agente.
2. El ciclo "for" itera sobre todas las coordenadas del agente, donde "coords" es el número total de coordenadas (o dimensiones) en el espacio de búsqueda.
3. Dentro del ciclo, el valor de la coordenada actual del agente se almacena en la variable "val".
4. Dependiendo de la probabilidad se determinará qué acción realizar:
- Búsqueda aleatoria - si el número aleatorio generado (a través de u.RNDprobab()) es menor que el valor "randomSearchProbability", se realizará una búsqueda aleatoria y la coordenada "c" se actualizará a través del método "ActionRandomSearch(c)", que generará una nueva posición en esta dimensión.
- Seguimiento de la danza - de lo contrario, el agente seguirá la "danza" de otros agentes. En este caso, la coordenada "c" se actualiza usando el método "ActionFollowingDance(c, val)", que utiliza el valor "val" para determinar la nueva posición basándose en información sobre otros agentes.
El método "StageActivityNovice" controla el comportamiento de los novatos en el algoritmo ABHA y, en última instancia, realiza las siguientes acciones clave:
1. Itera a través de cada coordenada del agente.
2. Dependiendo de una probabilidad aleatoria, decide si el agente realizará una búsqueda aleatoria o seguirá la "danza" de otros agentes.
3. Actualiza la posición del agente en cada coordenada según la acción seleccionada.
Este método permite a los recién llegados adaptarse al entorno usando tanto estrategias aleatorias como estrategias basadas la interacción con otros agentes.
//—————————————————————————————————————————————————————————————————————————————— //Actions 1 or 2 void C_AO_ABHA::StageActivityNovice (S_ABHA_Agent &agent) { double val; for (int c = 0; c < coords; c++) { val = agent.position [c]; if (u.RNDprobab () < randomSearchProbability) agent.position [c] = ActionRandomSearch (c); else agent.position [c] = ActionFollowingDance (c, val); } } //——————————————————————————————————————————————————————————————————————————————
El método "StageActivityExperienced" de la clase "C_AO_ABHA" es el responsable de las acciones de los agentes experimentados en el algoritmo ABHA y controla cómo los agentes experimentados eligen sus acciones dependiendo de probabilidades aleatorias y sus estrategias actuales.
1. Se declara una variable "rnd", que se usará para almacenar un número aleatorio generado para decidir qué debe hacer el agente.
2. El ciclo "for" itera sobre todas las coordenadas del agente, donde "coords" es el número total de coordenadas (o dimensiones) en el espacio de búsqueda.
3. Dentro del ciclo, se genera un número aleatorio "rnd" para cada coordenada utilizando el método "RNDprobab()", que retorna un valor entre "0" y "1".
4. Si el número aleatorio "rnd" es menor o igual a "agent.p_srs" (probabilidad de búsqueda aleatoria), el agente realizará una búsqueda aleatoria, actualizando su posición en la coordenada "c" utilizando el método "ActionRandomSearch(c)".
Probabilidad de continuar la danza:
- Si "rnd" es mayor que "agent.p_srs" y menor o igual que "agent.p_rul" (probabilidad de seguir la danza), el agente seguirá la "danza" de otros agentes, actualizando su posición con la ayuda de "ActionFollowingDance (c, agent.position [c])".
Probabilidad de permanecer en la fuente:
- Si no se cumple ninguna de las condiciones anteriores, el agente permanecerá en la fuente, actualizando su posición con el método "ActionHiveVicinity(c, agent.bestPosition[c])", donde "agent.bestPosition[c]" representará la posición más conocida del agente.
El método "StageActivityExperienced" controla el comportamiento de los agentes experimentados en el algoritmo ABHA y, en última instancia, hace lo siguiente:
1. Itera a través de cada coordenada del agente.
2. Genera un número aleatorio para seleccionar una acción.
3. Dependiendo del número generado y las probabilidades, determina si el agente realizará una búsqueda aleatoria, seguirá la "danza" de otros agentes o permanecerá en la fuente.
Este método permite a los agentes experimentados adaptarse al entorno usando estrategias más complejas que los novatos y así mejorar su rendimiento en la búsqueda de recursos.
//—————————————————————————————————————————————————————————————————————————————— //actions 1 or 2 or 4 void C_AO_ABHA::StageActivityExperienced (S_ABHA_Agent &agent) { double rnd = 0; for (int c = 0; c < coords; c++) { rnd = u.RNDprobab (); // random search probability if (rnd <= agent.p_srs) { agent.position [c] = ActionRandomSearch (c); } else { // Probability of following the dance if (agent.p_srs < rnd && rnd <= agent.p_rul) { agent.position [c] = ActionFollowingDance (c, agent.position [c]); } // Probability of remaining near the source else { agent.position [c] = ActionHiveVicinity (c, agent.bestPosition [c]); } } } } //——————————————————————————————————————————————————————————————————————————————
El método "StageActivitySearch" de la clase "C_AO_ABHA" es responsable de las acciones de los agentes durante la etapa de búsqueda y controla cómo se mueven los agentes en el espacio de búsqueda, actualizando sus posiciones dependiendo de la dirección elegida. El método realiza las siguientes acciones:
1. Itera a través de cada coordenada del agente.
2. Para cada coordenada, llama al método "ActionMovingDirection", que determina la nueva dirección del movimiento del agente.
3. Actualiza la posición del agente en la coordenada correspondiente.
Este método permite a los agentes moverse activamente en el espacio de búsqueda, adaptando sus posiciones según las direcciones elegidas.
//—————————————————————————————————————————————————————————————————————————————— //Actions 3 void C_AO_ABHA::StageActivitySearch (S_ABHA_Agent &agent) { for (int c = 0; c < coords; c++) { agent.position [c] = ActionMovingDirection (agent, c); } } //——————————————————————————————————————————————————————————————————————————————
El método "StageActivitySource" de la clase "C_AO_ABHA" está diseñado para realizar las acciones relacionadas con la determinación de las fuentes de alimento para los agentes en el modelo y la actualización de las posiciones de los agentes según sus mejores posiciones en el contexto de su presencia cerca de la colmena. El método realiza los siguientes pasos:
1. Inicializa la variable "val".
2. Itera a través de cada coordenada del agente.
3. Para cada coordenada, actualiza la posición del agente llamando al método "ActionHiveVicinity", que determina la nueva posición del agente en función de su mejor posición conocida.
Este método ayuda a los agentes en estado de explotación a concentrar toda su atención en una exploración detallada de los alrededores de una fuente de alimento conocida.
//—————————————————————————————————————————————————————————————————————————————— //Actions 4 void C_AO_ABHA::StageActivitySource (S_ABHA_Agent &agent) { double val = 0; for (int c = 0; c < coords; c++) { agent.position [c] = ActionHiveVicinity (c, agent.bestPosition [c]); } } //——————————————————————————————————————————————————————————————————————————————
El método "ActionRandomSearch" de la clase "C_AO_ABHA" está diseñado para realizar una búsqueda aleatoria en un rango dado de coordenadas y permite al agente seleccionar aleatoriamente un valor dentro de un rango determinado. El método ejecuta la función de exploración extendida del espacio de búsqueda y realiza las siguientes acciones:
1. Toma el índice de la coordenada para la que se debe generar un valor aleatorio.
2. Usa un método de generación de números aleatorios para obtener un valor en el rango definido por los valores mínimo y máximo para una coordenada dada.
3. Retorna un valor generado aleatoriamente de tipo "double".
//—————————————————————————————————————————————————————————————————————————————— //1. Random search (random placement in a range of coordinates) double C_AO_ABHA::ActionRandomSearch (int coordInd) { return u.RNDfromCI (rangeMin [coordInd], rangeMax [coordInd]); } //——————————————————————————————————————————————————————————————————————————————
El método "ActionFollowingDance" de la clase "C_AO_ABHA" implementa la lógica de seguimiento del "bailarín", lo cual implica moverse en la dirección de un agente que ya haya alcanzado un cierto nivel de experiencia. Este método usa un enfoque probabilístico para seleccionar el agente que seguirá al agente actual e introduce ruido aleatorio en la dirección calculada.
1. Cálculo de la probabilidad global:
- Se inicializa la variable "totalProbability", que almacenará la suma de las probabilidades "p_si" de todos los agentes en el estado "experimentado".
- En un ciclo, se comprueba el estado de todos los agentes y, si el agente tiene experiencia, su probabilidad se sumará a "totalProbability".
2. Generación de un valor aleatorio y selección de un agente:
- Se genera un valor aleatorio "randomValue" y se normaliza en relación con "totalProbability".
- En el siguiente ciclo se produce la acumulación de probabilidades "p_si" de los agentes experimentados. Cuando la probabilidad acumulada exceda "randomValue", se guardará el índice del agente seleccionado "ind" y se finalizará el ciclo.
3. Comprobación del agente seleccionado y cálculo del nuevo valor:
- Si no se ha seleccionado ningún agente (el índice "ind" ha permanecido igual a "-1"), se llamará al método "ActionRandomSearch" para realizar una búsqueda aleatoria.
- Si se ha seleccionado un agente, la dirección de movimiento "direction" se calculará como la diferencia entre la mejor posición del agente seleccionado y el valor actual "val".
- Genera el ruido aleatorio "noise" en el rango entre "-1" y "1".
- Se retorna un nuevo valor, que será el valor actual de "val" ajustado según la dirección y el ruido.
El método "ActionFollowingDance" implementa una estrategia de seguimiento de un agente experimentado (seleccionado por la regla de la ruleta, donde una abeja bailarina más experimentada tiene mayores posibilidades de ser seleccionada), utilizando un enfoque probabilístico para seleccionar al agente y agregando ruido aleatorio a la dirección del movimiento, lo cual hace que el comportamiento de los agentes resulte más diverso y adaptativo.
——————————————————————————————————————————————————————————————————————— //2. Follow the dance (move in the direction of the dancer) double C_AO_ABHA::ActionFollowingDance (int coordInd, double val) { //---------------------------------------------------------------------------- double totalProbability = 0; for (int i = 0; i < popSize; i++) { if (agents [i].state == S_ABHA_Agent::stateExperienced) { totalProbability += agents [i].p_si; } } //---------------------------------------------------------------------------- double randomValue = u.RNDprobab () * totalProbability; double cumulativeProbability = 0; int ind = -1; for (int i = 0; i < popSize; i++) { if (agents [i].state == S_ABHA_Agent::stateExperienced) { cumulativeProbability += agents [i].p_si; if (cumulativeProbability >= randomValue) { ind = i; break; } } } //---------------------------------------------------------------------------- if (ind == -1) { return ActionRandomSearch (coordInd); } double direction = agents [ind].bestPosition [coordInd] - val; double noise = u.RNDfromCI (-1.0, 1.0); return val + direction * noise; } //——————————————————————————————————————————————————————————————————————————————
El método "ActionMovingDirection" de la clase "C_AO_ABHA" es responsable del desplazamiento del agente en una dirección determinada con un paso determinado. Vamos a desglosar el código.
1. Movimiento del agente:
- Actualización de la posición del agente en la coordenada especificada "coordInd".
- agent.position [coordInd] - posición actual del agente en la coordenada dada.
- agent.stepSize - tamaño del paso en el que el agente se mueve en esta dirección.
- agent.direction [coordInd] - dirección del movimiento del agente a lo largo de la coordenada especificada.
- Multiplicando "stepSize" por "direction", obtenemos la magnitud de movimiento que se agrega a la posición actual del agente.
2. Disminución del tamaño del paso:
- Después del movimiento, el tamaño del paso "stepSize" se reduce por el factor "stepSizeReductionFactor".
- Esto es necesario para simular el efecto de la disminución del movimiento, cuando el agente comienza a moverse más lentamente para mejorar la solución encontrada.
El método "ActionMovingDirection" implementa una lógica simple para desplazar un agente en una dirección determinada, considerando el tamaño del paso y disminuyendo este paso después del movimiento.
//—————————————————————————————————————————————————————————————————————————————— //3. Move in a given direction with a step double C_AO_ABHA::ActionMovingDirection (S_ABHA_Agent &agent, int coordInd) { agent.position [coordInd] += agent.stepSize * agent.direction [coordInd]; agent.stepSize *= stepSizeReductionFactor; return agent.position [coordInd]; } //——————————————————————————————————————————————————————————————————————————————
El método "ActionHiveVicinity" de la clase "C_AO_ABHA" está diseñado para determinar el comportamiento del agente en la proximidad de una fuente de alimento. El método "ActionHiveVicinity" es responsable de generar una nueva posición en una coordenada dada, con mayor probabilidad en la proximidad de la posición actual que lejos de ella.
//—————————————————————————————————————————————————————————————————————————————— //4. Move in the vicinity of a food source double C_AO_ABHA::ActionHiveVicinity (int coordInd, double val) { return u.PowerDistribution (val, rangeMin [coordInd], rangeMax [coordInd], 12); } //——————————————————————————————————————————————————————————————————————————————
Veamos el siguiente método "ChangingStateForNovice" en la clase "C_AO_ABHA", que es responsable de cambiar el estado del agente dependiendo de su aptitud actual "cost" y la información sobre las fuentes de alimento.
1. En este método no se usan los costes anteriores ni los mejores.
2. Comprobación del estado:
- Si el coste actual de una fuente de alimento "agent.cost" supera el coste promedio "avgCost", entonces el estado del agente cambiará a experimentado "stateExperienced". Esto significará que el agente ha recibido suficiente información sobre fuentes de alimentos altamente rentables y estará listo para actuar de manera más eficiente.
3. Transición al estado "Explorador":
- Si el coste actual no supera el promedio, el agente pasará al estado de explorador "stateSearch". Este estado supone que el agente no tiene información sobre las fuentes de alimentos y deberá iniciar una búsqueda aleatoria.
4. Dirección aleatoria de búsqueda:
- El ciclo recorre todas las coordenadas "coords" y para cada coordenada se le asigna al agente una dirección aleatoria. El método "RNDfromCI" genera un número aleatorio en el rango especificado y se utiliza para determinar el tamaño del movimiento y la dirección dentro del rango especificado "rangeMin" y "rangeMax".
5. Inicialización de los parámetros de búsqueda:
- Para el movimiento del agente, se establece un tamaño de paso "stepSize", así como un contador de búsqueda "searchCounter", que monitorea la cantidad de iteraciones que el agente ha realizado en la búsqueda de alimento.
El método "ChangingStateForNovice" es responsable de cambiar el estado de la abeja "novata" dependiendo del valor de su fuente de alimento. Si el valor es alto, el agente adquirirá experiencia. Si el valor es bajo, el agente pasará al estado de explorador, iniciará una búsqueda aleatoria e inicializará los parámetros para esta búsqueda.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForNovice (S_ABHA_Agent &agent) { //Current cost : Used to enter either the Experienced or Search state. //Previous cost: Not used. //Best cost : Not used. //Into Experienced. If a novice receives information about a highly profitable food source (for example, through dances of other bees), it may transition to the experienced state. //Into Search. If a novice does not receive information about food sources, it may begin a random search and enter a search state. if (agent.cost > avgCost) agent.state = S_ABHA_Agent::stateExperienced; else { agent.state = S_ABHA_Agent::stateSearch; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } //——————————————————————————————————————————————————————————————————————————————
El método "ChangingStateForExperienced" en la clase "C_AO_ABHA" está diseñado para gestionar el estado de un agente abeja experimentado dependiendo de su valor de fuente de alimento actual y el valor anterior. Veamos este método con detalle.
1. Cambio del parámetro "pab":
- Si el valor actual es menor que el valor anterior: la abeja disminuirá la probabilidad de permanecer en la fuente de alimento "pab". Si "pab" se vuelve menor que "0", se establecerá en "0".
- Si el valor actual es mayor que el valor anterior: la abeja aumentará la probabilidad de permanecer en la fuente de alimento. Si "pab" es mayor que "1", se establecerá en "1".
- Si el valor actual supera al mejor valor: si el valor actual ha superado al mejor valor, la probabilidad de permanecer en la fuente se establecerá en el valor máximo "1".
2. Transición al estado "Explotador" o "Explorador":
- Si el coste actual es un 20% mayor que el promedio de la población: la abeja pasará al estado “Explotador” (stateSource), lo que significará que ha encontrado una buena fuente de alimento. La probabilidad de permanecer en la fuente se establecerá en "1".
- Si el coste actual es menor que el promedio: la abeja pasará al estado “Explorador” (stateSearch). Esto señalará la necesidad de buscar nuevas fuentes de alimentos.
3. Dirección aleatoria de búsqueda:
- En caso de transición al estado “Explorador”: la abeja recibirá instrucciones aleatorias para buscar nuevas fuentes de alimento.
4. Inicialización de los parámetros de búsqueda:
- Se establece un tamaño de paso para el movimiento del agente, así como un contador de búsqueda que monitorea el número de pasos dados en busca de comida.
El método "ChangingStateForExperienced" controla el estado de una abeja experimentada según su valor de fuente de alimento actual y sus valores anteriores. Usa una lógica basada en la comparación de valores actuales, anteriores y mejores para determinar si la abeja debe continuar explorando una fuente de alimento o buscar una nueva. El parámetro "pab" (probabilidad de permanecer en la fuente) se ajusta en función de los cambios en el coste.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForExperienced (S_ABHA_Agent &agent) { //Current cost : If the current value is high and the information is valid, it can pass this information on to other bees through a dance. //Previous cost: A bee compares the current value with the previous one to determine if the situation has improved. If the current value is better, it may increase the probability of passing the information. //Best cost : A bee can use the best value to assess whether to continue exploring a given food source or to look for a new one. //Into Search. If the information about the current food source is not good enough (e.g. the current fitness value is below the threshold), a bee may enter a search state to search for new sources. //Into Food Source. If information about a food source is confirmed (e.g. the current fitness value is high and stable), a bee may switch to a food source state to analyze the source in more depth. if (agent.cost < agent.prevCost) { agent.pab -= abandonmentRate; if (agent.pab < 0.0) agent.pab = 0.0; } if (agent.cost > agent.prevCost) { agent.pab += abandonmentRate; if (agent.pab > 1.0) agent.pab = 1.0; } if (agent.cost > agent.bestCost) agent.pab = 1.0; if (agent.cost > avgCost * 1.2) { agent.state = S_ABHA_Agent::stateSource; agent.pab = 1; } else if (agent.cost < avgCost) { agent.state = S_ABHA_Agent::stateSearch; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } //——————————————————————————————————————————————————————————————————————————————
Ahora veremos con más detalle el código del método "ChangingStateForSearch" de la clase "C_AO_ABHA", que controla el comportamiento del agente abeja en el proceso de búsqueda de una fuente de alimento. El método realiza los siguientes pasos:
1. Comparación del valor actual con el anterior:
- Si el valor actual "agent.cost" es menor que el "agent.prevCost" anterior, esto significará que la abeja se está alejando de una fuente buena. En este caso:
- La abeja cambiará su dirección generando valores aleatorios para cada dirección de coordenadas utilizando la función "u.RNDfromCI".
- Se establecerá el tamaño del paso inicial "inicialStepSize" y la abeja estará lista para continuar explorando.
- El aumento del contador de búsqueda "searchCounter" permite realizar un seguimiento del número de intentos de búsqueda.
2. Comparación del valor actual con el mejor:
- Si el valor actual es mayor que el mejor "agent.bestCost", esto significará que la abeja ha encontrado una fuente de alimento más rentable. En este caso:
- El tamaño del paso se reducirá según el factor especificado "stepSizeReductionFactor", lo cual indicará que se necesita un paso más pequeño para mejorar la solución encontrada.
- El contador de búsqueda se pondrá a "0" porque la abeja ha encontrado una fuente más rentable.
3. Comprobación del número máximo de intentos de búsqueda:
- Si el contador de búsqueda alcanza el número máximo de intentos "maxSearchAttempts", significará que la abeja no ha encontrado nada rentable en un determinado número de intentos. En este caso:
- El contador de búsqueda se restablecerá a "0".
- La abeja entrará en el estado "Novato" (stateNovice), esto significará que debe comenzar la búsqueda nuevamente.
4. Comprobación de una buena fuente de alimento:
- Si el valor actual es un 20% mayor que el coste promedio "avgCost", esto indicará que la abeja ha encontrado una buena fuente de alimento. En este caso:
- La abeja pasará al estado “Explotador” (stateSource), lo cual significa que continuará evaluando la rentabilidad de la fuente.
- La probabilidad de permanecer en la fuente "pab" se establecerá en "1", por lo que la abeja tendrá más probabilidades de permanecer en esta fuente.
El método ChangingStateForSearch controlará el comportamiento de la abeja en el estado de búsqueda, tomando decisiones basadas en comparaciones de valores de aptitud actuales, anteriores y mejores. Este permite a la abeja adaptarse al entorno y pasar a otros estados “Explotador” o “Novato”, ajustando el tamaño del paso en función de las fuentes de alimento encontradas.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForSearch (S_ABHA_Agent &agent) { //Current cost : A bee uses its current fitness value to assess its current position and to decide whether to continue searching or change direction //Previous value: A bee compares the current value with the previous one to determine if things have improved. If the current value is better, it can continue in the same direction. //Best value : The bee uses the best value to determine whether the current food source is more profitable than the previous ones. This helps it make decisions about whether to stay put or continue searching. //Into Food Source. If a searching bee finds a food source with good characteristics (e.g., the current fitness value is better than the threshold), it can switch to the food source state to evaluate the profitability of the source. //Into Novice. If a searching bee does not find any food sources or the information is impractical, it may revert to novice. if (agent.cost < agent.prevCost) { for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter++; } if (agent.cost > agent.bestCost) { agent.stepSize *= stepSizeReductionFactor; agent.searchCounter = 0; } if (agent.searchCounter >= maxSearchAttempts) { agent.searchCounter = 0; agent.state = S_ABHA_Agent::stateNovice; return; } if (agent.cost > avgCost * 1.2) { agent.state = S_ABHA_Agent::stateSource; agent.pab = 1; } } //——————————————————————————————————————————————————————————————————————————————
El método "ChangingStateForSource" de la clase "C_AO_ABHA" controlará el comportamiento del agente abeja durante la explotación de la fuente de alimento. Estructura general del método:
1. Transición al estado "Explorador":
- Si el valor actual "agent.cost" es menor que el coste promedio "avgCost", esto indicará que la fuente de alimento actual no es rentable.
- La abeja disminuye su probabilidad de permanecer en la fuente "pab" por el valor "abandonoRate", es decir, se vuelve menos probable que permanezca en la fuente actual.
- Si el valor aleatorio recibido de "u.RNDprobab" es mayor que "agent.pab", la abeja decidirá pasar al estado "Explorador" (stateSearch):
- La probabilidad "pab = 0" se restablecerá.
- La abeja cambia su dirección generando valores aleatorios para cada coordenada utilizando "u.RNDfromCI".
- Se establece el tamaño del paso inicial "initialStepSize" y el contador de búsqueda "searchCounter" se restablece a "0".
3. Transición al estado "Experimentado":
- Si el valor actual "agent.cost" es mayor que el mejor valor "agent.bestCost", significa que la fuente de alimento actual estará demostrando ser rentable.
- En este caso, la abeja pasará al estado "Experimentado" (stateExperienced) y continuará transmitiendo información sobre una buena fuente a otras abejas.
- La probabilidad de permanecer en la fuente "pab" se establece en "1", y la abeja permanecerá en esta fuente con la mayor probabilidad posible.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForSource (S_ABHA_Agent &agent) { //Current cost : If the current value is below the threshold, it may decide that the source is not good enough and start looking for a new one. //Previous value: The bee can use the previous value to compare and determine if the situation has improved. If the current value is worse, it may signal the need to change the strategy. //Best value : A bee uses the best value to decide whether to continue exploiting the current food source or to look for a new, more profitable one. //Into Search. If the current food source turns out to be impractical (e.g. the current fitness value is worse than the threshold), a bee may switch to a search state to search for new sources. //Into Experienced. If a food source bee finds a food source that proves beneficial, it may enter the experienced state to pass on the information to other bees. if (agent.cost < avgCost) { agent.pab -= abandonmentRate; if (u.RNDprobab () > agent.pab) { agent.state = S_ABHA_Agent::stateSearch; agent.pab = 0; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } if (agent.cost > agent.bestCost) { agent.state = S_ABHA_Agent::stateExperienced; agent.pab = 1; } } //—————————————————————————————————————————————————————————————————————————————
El método "CalculateProbabilities" de la clase "C_AO_ABHA" es responsable de calcular las probabilidades de diferentes acciones para cada agente (abeja) en función de sus costes actuales. El método realiza los siguientes pasos:
1. Inicialización de variables:
- maxCost se inicializa con el valor mínimo posible para garantizar que cualquier coste del agente sea mayor que este valor.
- minCost se inicializa con un valor máximo para que cualquier coste del agente pueda ser menor que este valor.
2. Búsqueda del coste máximo y mínimo:
- Se realiza un ciclo por todos los agentes (abejas) de la población "popSize".
- Dentro del ciclo, el coste actual del agente se compara con “maxCost” y “minCost”, actualizando sus valores si es necesario.
3. Cálculo del rango de valores:
- costRange es la diferencia entre el coste máximo y mínimo, que permite la normalización de probabilidades.
4. Cálculo de la probabilidades para cada agente:
- p_si - probabilidad de un agente en función de su valor. Cuanto mayor sea el coste, mayor será la probabilidad (normalizada al rango).
- p_srs - probabilidad de búsqueda aleatoria, indicada de antemano.
- p_rul - probabilidad de seguir la danza. Esto significa que cuanto mayor sea la probabilidad de permanecer en la fuente, menor será la probabilidad de seguir la danza.
- p_ab - probabilidad de permanecer en la fuente, igual a "pab" del agente.
Después de esto, se calculará la suma de las tres probabilidades y cada una de ellas se normalizará para que la suma de las probabilidades sea igual a "1". Esto se hace dividiendo cada probabilidad por la suma total.
El método "CalcularProbabilidades" permite a cada abeja estimar sus posibilidades de realizar diversas acciones (búsqueda aleatoria, seguir una danza, llegar a una fuente) según su coste actual.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::CalculateProbabilities () { double maxCost = -DBL_MAX; double minCost = DBL_MAX; for (int i = 0; i < popSize; i++) { if (agents [i].cost > maxCost) maxCost = agents [i].cost; if (agents [i].cost < minCost) minCost = agents [i].cost; } double costRange = maxCost - minCost; for (int i = 0; i < popSize; i++) { agents [i].p_si = (maxCost - agents [i].cost) / costRange; agents [i].p_srs = randomSearchProbability; // random search probability agents [i].p_rul = 1.0 - agents [i].pab; // probability of following the dance agents [i].p_ab = agents [i].pab; // probability of staying near the source double sum = agents [i].p_srs + agents [i].p_rul + agents [i].p_ab; agents [i].p_srs /= sum; agents [i].p_rul /= sum; agents [i].p_ab /= sum; } } //——————————————————————————————————————————————————————————————————————————————
El método "CalculateAverageCost" en la clase "C_AO_ABHA" se ha pensado para calcular el coste promedio de todos los agentes abeja en la población. Esta información es necesaria para analizar el estado de la población y tomar decisiones dentro del algoritmo. El coste promedio sirve como indicador del éxito de los agentes y también se usa en cálculos posteriores.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::CalculateAverageCost () { double totalCost = 0; for (int i = 0; i < popSize; i++) { totalCost += agents [i].cost; } avgCost = totalCost / popSize; } //———————
3. Resultados de las pruebas
Impresión del algoritmo ABHA:
ABHA|Artificial Bee Hive Algorithm|10.0|10.0|0.1|0.1|0.99|0.5|
=============================
5 Hilly's; Func runs: 10000; result: 0,8413125195861497
25 Hilly's; Func runs: 10000; result: 0,5422730855489947
500 Hilly's; Func runs: 10000; result: 0,2630407626746883
=============================
5 Forest's; Func runs: 10000; result: 0,8785786358650522
25 Forest's; Func runs: 10000; result: 0,47779307049664316
500 Forest's; Func runs: 10000; result: 0,17181208858518054
=============================
5 Megacity's; Func runs: 10000; result: 0,5092307692307693
25 Megacity's; Func runs: 10000; result: 0,3387692307692307
500 Megacity's; Func runs: 10000; result: 0,1039692307692317
=============================
All score: 4.12678 (45.85%)
Ya hemos terminado de escribir el código y realizado un análisis detallado de todos los componentes del algoritmo ABHA, ahora pasaremos directamente a probar el algoritmo con las funciones de prueba y evaluar su efectividad. En la visualización del funcionamiento del algoritmo, podemos ver una dispersión bastante fuerte en los resultados de las pruebas. En
ABHA en función de prueba Hilly.
ABHA en función de prueba Forest.
ABHA en función de prueba Megacity.
Según los resultados de la investigación, el algoritmo ocupa un lugar firme en mitad 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 | 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 | (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 |
| 4 | CTA | comet tail algorithm | 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 |
| 5 | 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 |
| 6 | ESG | evolution of social groups | 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 |
| 7 | SIA | simulated isotropic annealing | 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 |
| 8 | 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 |
| 9 | TSEA | turtle shell evolution algorithm | 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 |
| 10 | 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 |
| 11 | CRO | chemical reaction optimisation | 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 |
| 12 | 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 |
| 13 | 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 |
| 14 | 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 |
| 15 | (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 |
| 16 | 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 |
| 17 | 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 |
| 18 | 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 |
| 19 | 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 |
| 20 | 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 |
| 21 | 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 |
| 22 | 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 |
| 23 | 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 |
| 24 | 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 |
| 25 | 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 |
| 26 | 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 |
| 27 | 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 |
| 28 | 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 |
| 29 | 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 |
| 30 | 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 |
| 31 | 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 |
| 32 | 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 |
| 33 | BA | bat algorithm | 0,59761 | 0,45911 | 0,35242 | 1,40915 | 0,40321 | 0,19313 | 0,07175 | 0,66810 | 0,21000 | 0,10100 | 0,03517 | 0,34617 | 2,423 | 26,93 |
| 34 | SA | simulated annealing | 0,55787 | 0,42177 | 0,31549 | 1,29513 | 0,34998 | 0,15259 | 0,05023 | 0,55280 | 0,31167 | 0,10033 | 0,02883 | 0,44083 | 2,289 | 25,43 |
| 35 | IWDm | intelligent water drops M | 0,54501 | 0,37897 | 0,30124 | 1,22522 | 0,46104 | 0,14704 | 0,04369 | 0,65177 | 0,25833 | 0,09700 | 0,02308 | 0,37842 | 2,255 | 25,06 |
| 36 | PSO | particle swarm Optimization | 0,59726 | 0,36923 | 0,29928 | 1,26577 | 0,37237 | 0,16324 | 0,07010 | 0,60572 | 0,25667 | 0,08000 | 0,02157 | 0,35823 | 2,230 | 24,77 |
| 37 | Boids | boids algorithm | 0,43340 | 0,30581 | 0,25425 | 0,99346 | 0,35718 | 0,20160 | 0,15708 | 0,71586 | 0,27846 | 0,14277 | 0,09834 | 0,51957 | 2,229 | 24,77 |
| 38 | MA | monkey algorithm | 0,59107 | 0,42681 | 0,31816 | 1,33604 | 0,31138 | 0,14069 | 0,06612 | 0,51819 | 0,22833 | 0,08567 | 0,02790 | 0,34190 | 2,196 | 24,40 |
| 39 | SFL | shuffled frog-leaping | 0,53925 | 0,35816 | 0,29809 | 1,19551 | 0,37141 | 0,11427 | 0,04051 | 0,52618 | 0,27167 | 0,08667 | 0,02402 | 0,38235 | 2,104 | 23,38 |
| 40 | FSS | fish school search | 0,55669 | 0,39992 | 0,31172 | 1,26833 | 0,31009 | 0,11889 | 0,04569 | 0,47467 | 0,21167 | 0,07633 | 0,02488 | 0,31288 | 2,056 | 22,84 |
| 41 | RND | random | 0,52033 | 0,36068 | 0,30133 | 1,18234 | 0,31335 | 0,11787 | 0,04354 | 0,47476 | 0,25333 | 0,07933 | 0,02382 | 0,35648 | 2,014 | 22,37 |
| 42 | GWO | grey wolf optimizer | 0,59169 | 0,36561 | 0,29595 | 1,25326 | 0,24499 | 0,09047 | 0,03612 | 0,37158 | 0,27667 | 0,08567 | 0,02170 | 0,38403 | 2,009 | 22,32 |
| 43 | CSS | charged system search | 0,44252 | 0,35454 | 0,35201 | 1,14907 | 0,24140 | 0,11345 | 0,06814 | 0,42299 | 0,18333 | 0,06300 | 0,02322 | 0,26955 | 1,842 | 20,46 |
| 44 | EM | electroMagnetism-like algorithm | 0,46250 | 0,34594 | 0,32285 | 1,13129 | 0,21245 | 0,09783 | 0,10057 | 0,41085 | 0,15667 | 0,06033 | 0,02712 | 0,24412 | 1,786 | 19,85 |
Conclusiones
Hoy hemos probado exhaustivamente el algoritmo ABHA en varias funciones de prueba y los resultados han demostrado que es competitivo con otros algoritmos basados en inteligencia de enjambre. Durante estas pruebas, el ABHA ha demostrado su eficacia y fiabilidad.
Los estudios destacan el potencial del algoritmo ABHA para resolver no solo problemas de optimización tradicionales sino también problemas más complejos como la optimización multiobjetivo y los problemas restringidos. Mis impresiones personales del trabajo realizado y la compleja lógica del algoritmo son las siguientes: esperaba obtener resultados más notables. Sin embargo, debemos señalar que los resultados del ABHA son realmente incomparables entre los algoritmos de enjambre.
En general, el algoritmo puede evaluarse como un conjunto de métodos y técnicas específicos aplicables a la gran mayoría de otros algoritmos de optimización. La capacidad de reproducir resultados y adaptarse a diferentes condiciones hace de este algoritmo una herramienta prometedora en el campo de la optimización computacional. De esta forma, el ABHA no solo amplía los horizontes de aplicación de los algoritmos de optimización, sino que también abre nuevas oportunidades para la investigación en el campo de la inteligencia artificial y su aplicación práctica.
Figura 1. Gradación por colores de los algoritmos según sus respectivas pruebas. En blanco se resaltan los resultados mayores o iguales a 0,99
Figura 2. Histograma de los resultados de las pruebas de los algoritmos (en una escala de 0 a 100, cuanto mayor, mejor),
donde 100 es el máximo resultado teórico posible; el script para calcular la tabla de clasificación está en el archivo)
Ventajas y desventajas del algoritmo de colmena artificial (ABHA):
Ventajas:
- Buenos resultados en problemas de baja dimensionalidad.
- Buenos resultados en funciones discretas.
Desventajas:
- Implementación de la lógica y de algoritmos complejos.
- Baja convergencia en problemas de alta dimensionalidad sobre funciones suaves.
- Gran número de parámetros externos.
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.
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/15486
Características del Wizard MQL5 que debe conocer (Parte 33): Núcleos de procesos gaussianos
Redes neuronales en el trading: Inyección de información global en canales independientes (InjectTST)
Analizamos ejemplos de estrategias comerciales en el terminal de cliente
Integración de MQL5 con paquetes de procesamiento de datos (Parte 2): Aprendizaje automático (Machine Learning, ML) y análisis predictivo
- 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