Algoritmo de colmena artificial — Artificial Bee Hive Algorithm (ABHA): Teoría y métodos
454
0
1. Introducción
En uno de los artículos anteriores ya analizamos el algoritmo ABC, que supone un ejemplo sorprendente de cómo la naturaleza inspira la creación de métodos computacionales eficientes. Una colonia de abejas no es solo un grupo de insectos, sino un sistema altamente organizado en el que cada abeja desempeña su propia función única. Algunas abejas se convierten en exploradoras e investigan los alrededores en busca de alimento, mientras que otras asumen el papel de recolectoras, recolectando néctar y polen. Esta forma de cooperación permite que la colonia sea más eficiente en la búsqueda de recursos que si cada abeja actuara por separado.
El nuevo algoritmo de colmena artificial que describimos en este artículo ofrece una visión más completa y profunda del comportamiento en la búsqueda de alimento de las abejas, demostrando cómo la interacción colectiva y las asignaciones de roles facilitan la búsqueda de nuevas fuentes de alimento. Asimismo, demuestra cómo las interacciones entre agentes pueden conducir a resultados más eficientes. Este algoritmo analiza más de cerca los roles individuales de cada individuo en una colonia de abejas.
El objetivo principal del ABHA es encontrar soluciones óptimas en espacios de alta dimensión donde las funciones pueden tener muchos mínimos y máximos locales. Esto hace que el problema de optimización resulte particularmente desafiante, ya que los métodos tradicionales pueden estancarse en extremos locales sin alcanzar el óptimo global. El algoritmo ABHA se inspira en las eficientes estrategias de búsqueda de alimento usadas por las abejas. En la naturaleza, las abejas usan métodos colectivos para encontrar eficientemente fuentes de néctar, y este principio se ha adaptado para crear un algoritmo que puede mejorar el proceso de búsqueda de soluciones óptimas.
La estructura ABHA incluye varios estados que reflejan la dinámica del comportamiento de las abejas. Uno de estos estados es el "estado experimental", durante el cual las abejas intercambian información sobre las fuentes de alimento encontradas. Este estado promueve la acumulación de conocimiento sobre las áreas más productivas del espacio multidimensional. Otro estado importante es el "estado de búsqueda", cuando las abejas exploran activamente el espacio en busca de las mejores fuentes, usando para ello la información recibida de sus congéneres.
El algoritmo de colmena artificial (ABHA) fue desarrollado en 2009 por un grupo de investigadores liderado por André Muñoz y está orientado a resolver problemas de optimización continua.
2. Implementación del algoritmo
El ABHA es un método interesante que utiliza una analogía con el comportamiento de las abejas para resolver problemas de optimización difíciles en espacios de búsqueda continua. Echemos un vistazo a los conceptos básicos del algoritmo:
1. Modelado del comportamiento de las abejas :
- El ABHA se basa en el modelo del comportamiento individual de las abejas. Cada agente (abeja) del algoritmo sigue un conjunto de reglas de comportamiento para determinar qué acciones tiene que realizar.
2. Interacción dentro de la colmena :
- El enfoque principal del ABHA está en las interacciones entre las abejas.
- Las abejas intercambian información sobre las soluciones encontradas.
| Estado de la abeja | Tipos de comportamiento |
|---|---|
| Novato (Novice state) | Se encuentra en una “colmena” (una posición abstracta donde se intercambia información) y no posee información sobre las fuentes de alimento. |
| Experimentado (Experimented state) | Tiene información sobre la fuente de alimentos y puede compartir dicha información. |
| Explorador (Search state) | Busca una fuente de alimento mejor que la actual. |
| Explotador (Food source state) | Evalúa la rentabilidad de su fuente de alimento y decide si merece la pena declararla. |
Cada uno de estos estados refleja diferentes aspectos del comportamiento de las abejas en la búsqueda y explotación de las fuentes de alimento. Cada estado de una abeja representa un conjunto de reglas que la abeja correspondiente sigue:
| Estado de la abeja | Reglas para cambiar la posición de una abeja en el espacio. |
|---|---|
| Novato | La abeja puede iniciar una búsqueda aleatoria o seguir una danza si hay alguna disponible. Si no hay información disponible sobre la fuente de alimento, puede iniciar una búsqueda aleatoria. |
| Experimentado | Si la información sobre una fuente de alimento es válida, la abeja en cuestión puede transmitirla a otras abejas a través de la danza. Si la información no es válida, puede iniciar una búsqueda aleatoria. |
| Explorador | La abeja cambia su posición usando información sobre la dirección y el tamaño del paso hasta que encuentra la mejor fuente de alimento. |
| Explotador | La abeja valora la rentabilidad de la fuente y, si no cumple los criterios, puede cambiar la dirección de la búsqueda. |
No todas las abejas pueden compartir información sobre una fuente de alimento, y no todas las abejas pueden recibir información de otras abejas que posean esta capacidad. Existen dos tipos de abejas que tienen la capacidad de recibir o transmitir información sobre una fuente de alimento:
1. Las que tienen la capacidad de transmitir información:
- Tipo experimentado: puede transmitir información a otras abejas a través de la danza si la información sobre la fuente de alimento es válida.
2. Tiene la capacidad de recibir información a través de la danza de otras abejas:
- Tipo novato: puede seguir la danza si está disponible para obtener información sobre las fuentes de alimento.
- Tipo experimentado: puede recibir información a través de la danza de otras abejas y tiene acceso a información sobre fuentes de alimento.
Las abejas pueden cambiar sus estados dependiendo de las condiciones relacionadas con su experiencia y la información sobre las fuentes de alimento. A continuación le enumeramos los tipos de abejas y las condiciones en las que pueden pasar de un estado a otro:
1. Novato
- A experimentado. Si un recién llegado recibe información sobre una fuente de alimento altamente rentable (por ejemplo, a través de la danza de otras abejas), puede pasar al estado experimentado.
- A explorador. Si un recién llegado no recibe información sobre las fuentes de alimentos, puede comenzar a buscar por su cuenta y entrar en un estado de explorador.
2. Experimentado
- A explorador. Si la información sobre la fuente de alimento actual no resulta lo suficientemente buena (por ejemplo, el valor de aptitud actual está por debajo del umbral), la abeja puede entrar en un estado de explorador para buscar nuevas fuentes.
- A explotador. Si se confirma la información sobre una fuente de alimento (por ejemplo, el valor de aptitud actual es alto y estable), la abeja puede cambiar a un estado explotador para analizar la fuente en mayor profundidad.
3. Explorador
- A explotador. Si un explorador encuentra una fuente de alimento con buenas características (por ejemplo, el valor de aptitud actual es mejor que el umbral), puede cambiar al estado de explotador para evaluar periódicamente la rentabilidad de dicha fuente.
- A novato. Si el explorador no encuentra ninguna fuente de alimento o la información no es lo suficientemente valiosa, puede volver al estado de novato.
4. Explotador
- A explorador. Si la fuente de alimento actual resulta no ser rentable (por ejemplo, el valor de aptitud actual es peor que el umbral), la abeja puede ingresar al estado explorador para buscar nuevas fuentes.
- A experimentado. Si un explotador encuentra una fuente de alimento que resulte rentable, puede entrar en el estado experimentado para transmitir la información a otras abejas.
Dichas transiciones de estado permiten que el algoritmo cambie dinámicamente su estrategia de búsqueda dependiendo de la posición de cada individuo en el espacio de la solución e intercambie eficientemente información sobre las fuentes de alimento.
El concepto de "fuente de alimento" y "danza" de las abejas juega un papel importante en el algoritmo. En el contexto del algoritmo, la "fuente de alimento" representa una solución potencial al problema de optimización:
1. Cada "fuente de alimento" se corresponde con una posición específica que representa una posible solución al problema de optimización en el espacio de búsqueda.
2. La calidad o "rentabilidad" de una fuente de alimento está determinada por el valor de la función objetivo en ese punto. Cuanto mayor sea el valor de la función objetivo, más "rentable" será la fuente de alimento.
3. Las abejas en el algoritmo buscan y explotan las fuentes de alimento más "rentables ", es decir, aquellas posiciones que corresponden a los mejores valores de la función objetivo.
4. El agotamiento de una fuente de alimento significa que no se puede encontrar una solución mejor en un punto determinado del espacio de búsqueda y las abejas deben cambiar la búsqueda a áreas nuevas y más prometedoras.
En el algoritmo, la "danza" es una forma que tienen las abejas de intercambiar información sobre las "fuentes de alimento" que han encontrado, de la siguiente manera:
- Cuando una abeja encuentra una "fuente de alimento" prometedora, regresa a la "colmena" y realiza una "danza".
- La duración de la "danza" depende de la "rentabilidad" de la fuente de alimento encontrada: cuanto mejor sea la solución, más larga será la "danza".
- Otras abejas en la colmena pueden escuchar esta "danza" y obtener información sobre la fuente de alimento. La probabilidad de que una abeja siga la "danza" depende de la "rentabilidad" de la fuente.
Así, la "fuente de alimento" en el algoritmo ABHA es un análogo de una solución potencial al problema de optimización, mientras que su "rentabilidad" está determinada por el valor de la función objetivo en el punto correspondiente en el espacio de búsqueda, y la "danza" sirve como una forma de transmitir información entre abejas sobre las soluciones más prometedoras encontradas en el proceso de búsqueda.
En el algoritmo ABHA, cada tipo de abeja usa los valores de aptitud (o coste) del paso anterior, el paso actual y el mejor valor de aptitud de la siguiente manera:
| Estado de la abeja | Novato | Experimentado | Explorador | Explotador |
|---|---|---|---|---|
| Valor actual | Se usa para ingresar al estado Experimentado o Explorador. | Si el valor actual es alto y la información es válida, puede transmitir esta información a otras abejas a través de una danza. | La abeja usa su valor de aptitud actual para evaluar su posición actual y decidir si continúa buscando o cambia de dirección. | Si el valor actual está por debajo del umbral, puede decidir que la fuente no es lo suficientemente buena y comenzar a buscar una nueva. |
| Valor anterior | No utilizado | La abeja compara el valor actual con el anterior para determinar si la situación ha mejorado, y si el valor actual es mejor, puede aumentar la probabilidad de transferencia de información. | La abeja compara el valor actual con el anterior para determinar si la situación ha mejorado; si el valor actual es mejor, puede continuar en la misma dirección. | No utilizado |
| El mejor valor | No utilizado | La abeja puede usar el mejor valor para evaluar si debe continuar explorando una fuente de alimento determinada o buscar una nueva. | La abeja usa el mejor valor para determinar si la fuente de alimento actual es más rentable que la actual. Esto le ayuda a tomar decisiones sobre si quedarse donde está o seguir buscando. | La abeja usa el mejor valor para decidir si continúa explotando la fuente de alimento actual o pasa al estado experimentado. |
Cada tipo de abeja usa información de aptitud en diferentes iteraciones para tomar decisiones y pasar a diferentes estados.
En el algoritmo, las probabilidades de selección de acciones, como la probabilidad de búsqueda aleatoria, la probabilidad de seguir una danza y la probabilidad de abandonar la fuente (o permanecer cerca de ella), se calculan dinámicamente a lo largo del proceso de optimización. Estas probabilidades ayudan a los agentes (abejas) a tomar decisiones sobre cómo actuar según la información actual y el estado del entorno.
Calcular probabilidades:
1. Probabilidad de búsqueda aleatoria (Psrs). ¿Qué probabilidad hay de que una abeja inicie una búsqueda aleatoria en lugar de seguir una danza o permanecer en la fuente de alimento actual?
2. Probabilidad de seguir una danza (Prul). ¿Qué probabilidad hay de que una abeja siga la danza de otra abeja?
3. Probabilidad de rechazo de la fuente (Pab). ¿Qué probabilidad hay de que una abeja permanezca en una fuente de alimento actual o la abandone?
Las abejas en diferentes estados usan las probabilidades de manera distinta, y las probabilidades para cada estado también son diferentes:
1. Novato :
- Psrs: alta, ya que la abeja no tiene información sobre otras fuentes y puede iniciar una búsqueda aleatoria.
- Prul: se puede utilizar si otras abejas están danzando, pero la probabilidad dependerá de la información disponible.
- Pab: no se aplica porque la abeja aún no ha encontrado una fuente de alimento.
2. Experimentado :
- Psrs: baja, ya que la abeja ya tiene información sobre la fuente.
- Prul: se utiliza para transmitir información a otras abejas si la información de origen se considera válida.
- Pab: se puede utilizar para decidir si se continúa explorando una fuente actual o se abandona si su rentabilidad es baja.
3. Explorador :
- Psrs: se puede utilizar si la abeja no encuentra fuentes satisfactorias.
- Prul: se puede usar si una abeja decide seguir la danza de otra abeja para encontrar una nueva fuente.
- Pab: se usa para evaluar si se debe continuar la búsqueda o regresar al “nido”.
4. Explotador :
- Psrs: baja, porque la abeja ya ha encontrado la fuente.
- Prul: se usa para transmitir información sobre una fuente válida a otras abejas si la fuente se considera rentable.
- Pab: alta, si la fuente no produce resultados satisfactorios, lo que puede llevar a la decisión de abandonarla.
Esperamos haber abarcado todos los matices del comportamiento de las abejas; ahora podemos comenzar a escribir el pseudocódigo.
Inicialización:
Se establecen los parámetros del algoritmo (popSize, maxSearchAttempts, abandonmentRate, etc.)
Se crea una población de agentes popSize con posiciones aleatorias
Se establece el estado inicial de cada agente en "Novato"
Ciclo principal:
Hasta que se alcance la condición de parada:
Para cada agente:
Se realiza una acción dependiendo del estado actual:
"Novato": búsqueda aleatoria o seguir la danza
"Experimentado": búsqueda aleatoria, seguir la danza o búsqueda local
"Explorador": movimiento en una dirección determinada
"Explotador": búsqueda local en torno a la mejor posición
Se califica la aptitud del agente
Se actualiza la mejor solución global si se encuentra
Se calculan las probabilidades y costes medios de las soluciones
Para cada agente:
Se actualiza el estado:
"Novato": transición a "Experimentado" o "Explorador"
"Experimentado": posible transición a "Explotador" o "Explorador"
"Explorador": posible transición a "Novato" o "Explotador"
"Explotador": posible transición a "Explorador" o "Experimentado"
Se actualiza la mejor posición y valor personal
Se calculan las probabilidades para los agentes
Se calcular el coste promedio
Ahora comenzaremos a escribir el código del algoritmo. La lógica de ABHA es bastante compleja y el código es voluminoso, por lo que describiremos la estructura, la clase y los métodos involucrados en el funcionamiento con el mayor detalle posible.
La estructura S_ABHA_Agent representa al agente "abeja" en el algoritmo basado en el comportamiento de las abejas. Descripción de la estructura:
1. La enumeración "BeeState" define los diferentes estados de una abeja:
- stateNovice - estado de un novato cuando la abeja apenas está comenzando su actividad.
- stateExperienced - estado de una abeja experimentada que ya tiene algo de experiencia.
- stateSearch - estado de la búsqueda cuando la abeja está buscando activamente fuentes de alimento.
- stateSource - estado de proximidad respecto a una fuente y evaluación periódica de la misma.
2. Campos de la estructura:
- position [] - array de la posición actual de la abeja en el espacio.
- bestPosition[] - array de la mejor posición de abeja encontrada.
- direction [] - array de vectores de dirección de movimiento de la abeja.
- cost - valor de la calidad de la fuente de alimentos actual.
- prevCost - valor de calidad de la fuente de alimento anterior.
- bestCost - valor de calidad de la mejor fuente de alimentos encontrada.
- stepSize - coeficiente del tamaño de paso de la abeja cuando se mueve a lo largo de las coordenadas.
- state - estado actual de la abeja, representado como un número entero.
- searchCounter - contador de las acciones de la abeja en el estado de búsqueda.
3. Campos de la estructura que indican probabilidades:
- pab - probabilidad de permanecer cerca de la fuente de alimento.
- p_si - probabilidad dinámica de que otras abejas elijan la danza de esta abeja.
- p_srs - probabilidad de búsqueda aleatoria.
- p_rul - probabilidad de seguir la danza.
- p_ab - probabilidad de permanecer cerca de la fuente de alimento.
4. Método " Init":
- Inicializa el agente tomando como entrada el número de coordenadas "coords" y el tamaño del paso inicial "initStepSize".
- El método asigna memoria para los arrays, y establece los valores iniciales para todos los miembros de la estructura, incluidos el estado, los contadores y las probabilidades.
La estructura "S_ABHA_Agent" se utiliza para modelar el comportamiento de una abeja en el algoritmo, donde la abeja puede encontrarse en diferentes estados, explorar el espacio en busca de alimento e interactuar con otras abejas. La inicialización de la estructura permite establecer los parámetros iniciales necesarios para iniciar el algoritmo.
//—————————————————————————————————————————————————————————————————————————————— struct S_ABHA_Agent { enum BeeState { stateNovice = 0, // Novice state stateExperienced = 1, // Experienced state stateSearch = 2, // Search state stateSource = 3 // Food source state }; double position []; // Current position of the bee double bestPosition []; // Best bee position found double direction []; // Bee movement direction vector double cost; // Current food source quality double prevCost; // Previous food source quality double bestCost; // Best food source found quality double stepSize; // Step ratio in all coordinates during a bee movement int state; // Bee's current state int searchCounter; // Counter of the bee actions in the search state double pab; // Probability of remaining near the source double p_si; // Dynamic probability of other bees choosing this bee's dance double p_srs; // Random search probability double p_rul; // Probability of following the dance double p_ab; // Probability of source rejection void Init (int coords, double initStepSize) { ArrayResize (position, coords); ArrayResize (bestPosition, coords); ArrayResize (direction, coords); cost = -DBL_MAX; prevCost = -DBL_MAX; bestCost = -DBL_MAX; state = stateNovice; searchCounter = 0; pab = 0; p_si = 0; p_srs = 0; p_rul = 0; p_ab = 0; stepSize = initStepSize; } }; //——————————————————————————————————————————————————————————————————————————————
La clase "C_AO_ABHA" hereda de la clase básica "C_AO", lo cual implica que utiliza la funcionalidad definida en la clase padre. Descripción de la clase:
1. Constructor "C_AO_ABHA ()":
- Establece los parámetros como el tamaño de la población "popSize", el número máximo de intentos de búsqueda "maxSearchAttempts", los coeficientes para las distintas probabilidades y el tamaño del paso inicial "initialStepSize".
- Inicializa el array "params", que contiene los parámetros del algoritmo.
2. Método "SetParams()" - establece los valores de los parámetros del algoritmo según los valores almacenados en el array "params".
3. Método "Init()" - inicializa el algoritmo adoptando como entrada los valores mínimo y máximo del rango de búsqueda, el paso de búsqueda y el número de épocas.
4. Métodos "Moving()" y "Revision()" - están diseñados para ejecutar la lógica del movimiento de los agentes (abejas) y revisar las soluciones encontradas.
5. Miembros de la clase:
- maxSearchAttempts - número máximo de intentos de búsqueda.
- abandonmentRate - paso de cambio en la probabilidad de permanecer en la fuente de alimento.
- randomSearchProbability - probabilidad de búsqueda aleatoria.
- stepSizeReductionFactor - coeficiente de reducción del tamaño del paso.
- initialStepSize - tamaño de paso inicial.
- S_ABHA_Agent agents [] - array de agentes (abejas) que participan en el algoritmo.
- avgCost - coste medio de la solución encontrada.
6. Métodos de actividad de las abejas:
- ActionRandomSearch () - búsqueda aleatoria en un rango determinado.
- ActionFollowingDance() - sigue la danza de otra abeja.
- ActionMovingDirection () - moverse en una dirección determinada considerando el tamaño del paso.
- ActionHiveVicinity() - movimiento en las proximidades de una fuente de alimento.
7. Métodos de actividad de las abejas en diferentes estados: StageActivityNovice (), StageActivityExperienced (), StageActivitySearch (), StageActivitySource () - definen las acciones de las abejas según su estado.
8. Métodos para cambiar el estado de las abejas: ChangingStateForNovice (), ChangingStateForExperienced (), ChangingStateForSearch (), ChangingStateForSource () - cambian el estado de las abejas dependiendo de su actividad.
9. Métodos de cálculo:
- CalculateProbabilities() - calcula las probabilidades de las acciones de las abejas.
- CalculateAverageCost() - calcula el coste promedio de las soluciones encontradas.
La clase "C_AO_ABHA" implementa un algoritmo de optimización basado en el comportamiento de las abejas y abarca varios aspectos del trabajo de las abejas, como el movimiento, la toma de decisiones y los cambios de estado.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_ABHA : public C_AO { public: C_AO_ABHA () { ao_name = "ABHA"; ao_desc = "Artificial Bee Hive Algorithm"; ao_link = "https://www.mql5.com/en/articles/15347"; popSize = 10; maxSearchAttempts = 10; abandonmentRate = 0.1; randomSearchProbability = 0.1; stepSizeReductionFactor = 0.99; initialStepSize = 0.5; ArrayResize (params, 6); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "maxSearchAttempts"; params [1].val = maxSearchAttempts; params [2].name = "abandonmentRate"; params [2].val = abandonmentRate; params [3].name = "randomSearchProbability"; params [3].val = randomSearchProbability; params [4].name = "stepSizeReductionFactor"; params [4].val = stepSizeReductionFactor; params [5].name = "initialStepSize"; params [5].val = initialStepSize; } void SetParams () { popSize = (int)params [0].val; maxSearchAttempts = (int)params [1].val; abandonmentRate = params [2].val; randomSearchProbability = params [3].val; stepSizeReductionFactor = params [4].val; initialStepSize = params [5].val; } bool Init (const double &rangeMinP [], //minimum search range const double &rangeMaxP [], //maximum search range const double &rangeStepP [], //step search const int epochsP = 0); //number of epochs void Moving (); void Revision (); //---------------------------------------------------------------------------- int maxSearchAttempts; double abandonmentRate; double randomSearchProbability; double stepSizeReductionFactor; double initialStepSize; S_ABHA_Agent agents []; private: //------------------------------------------------------------------- double avgCost; //Types of bees' actions---------------------------------------------------------- double ActionRandomSearch (int coordInd); //1. Random search (random placement in a range of coordinates) double ActionFollowingDance (int coordInd, double val); //2. Follow the dance (move in the direction of the dancer) double ActionMovingDirection (S_ABHA_Agent &agent, int coordInd); //3. Move in a given direction with a step double ActionHiveVicinity (int coordInd, double val); //4. Move in the vicinity of a food source //Actions of bees in different states---------------------------------------- void StageActivityNovice (S_ABHA_Agent &agent); //actions 1 or 2 void StageActivityExperienced (S_ABHA_Agent &agent); //actions 1 or 2 or 4 void StageActivitySearch (S_ABHA_Agent &agent); //actions 3 void StageActivitySource (S_ABHA_Agent &agent); //actions 4 //Change bees' state---------------------------------------------------- void ChangingStateForNovice (S_ABHA_Agent &agent); void ChangingStateForExperienced (S_ABHA_Agent &agent); void ChangingStateForSearch (S_ABHA_Agent &agent); void ChangingStateForSource (S_ABHA_Agent &agent); void CalculateProbabilities (); void CalculateAverageCost (); }; //——————————————————————————————————————————————————————————————————————————————
El método "Init" de la clase "C_AO_ABHA" es responsable de inicializar el algoritmo ABHA. Vamos a desglosarlo por elementos:
1. Parámetros del método:
- rangeMinP[] - array de valores mínimos para el rango de búsqueda. Estos son los límites inferiores para cada variable que se optimizará.
- rangeMaxP[] - array de valores máximos para el rango de búsqueda. Estos son los límites superiores para cada variable.
- rangeStepP[] - array de pasos de búsqueda. Estos son valores que determinan cuánto cambian las variables durante la búsqueda.
- epochsP - número de épocas (iteraciones) durante las cuales se ejecutará el algoritmo.
2. El método retorna "true" si la inicialización ha tenido éxito y "false" si ha sucedido un error.
Lógica del método:
- Se llama al método "StandardInit" con los parámetros del rango de búsqueda. Este método realiza las operaciones de inicialización estándar, como el establecimiento de los límites y los pasos de búsqueda. Si la inicialización falla, el método "Init" finaliza y retorna "false".
- El método "ArrayResize" cambia el tamaño del array "agents", que representa a las abejas (agentes) en el algoritmo. El tamaño del array se establece en "popSize", que determina la cantidad de agentes que participan en la optimización.
- El ciclo inicializa cada agente en el array "agents". Para cada agente, se llama al método "Init", que establece sus coordenadas iniciales (del array "coords") y el tamaño del paso inicial "initialStepSize". Este paso determina hasta dónde puede desplazarse el agente durante el proceso de búsqueda.
El método "Init" de la clase "C_AO_ABHA" realiza las siguientes tareas:
- Comprueba si la inicialización estándar de los parámetros de búsqueda ha tenido éxito.
- Cambia el tamaño del array del agente al número dado de abejas.
- Inicializa cada agente usando su propio método "Init", configurando los parámetros iniciales necesarios para que el algoritmo funcione.
Si todos los pasos se completan correctamente, el método retornará "true", lo que indicará una inicialización exitosa del algoritmo.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_ABHA::Init (const double &rangeMinP [], //minimum search range const double &rangeMaxP [], //maximum search range const double &rangeStepP [], //step search const int epochsP = 0) //number of epochs { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; ArrayResize (agents, popSize); for (int i = 0; i < popSize; i++) { agents [i].Init (coords, initialStepSize); } return true; } //————————————————————
A continuación, analizaremos el método “Moving” de la clase “C_AO_ABHA”, que implementa la etapa de movimiento del agente en el algoritmo. El método "Moving" no toma parámetros y no retorna ningún valor. Controla el movimiento de los agentes (abejas) durante la optimización. Lógica del método:
1. Inicialización inicial.
- Se comprueba la variable "revision": si es igual a "false", esta será la primera llamada al método y las posiciones del agente deberán inicializarse.
- Generación de posiciones iniciales: los ciclos anidados iterarán sobre todos los agentes y coordenadas. Para cada coordenada:
- Se genera un valor aleatorio "val" dentro del rango dado ("rangeMin" y "rangeMax").
- Este valor se ajusta luego usando el método "SeInDiSp", que establece el valor en el rango aceptable con un paso determinado.
- Se establecen la posición actual y la mejor posición del agente (al principio son la misma).
- Se genera una dirección aleatoria de desplazamiento del agente.
- Una vez completada la inicialización, "revision" se establece en "true" y el método finaliza.
2. Lógica básica del movimiento del agente. Desplazamiento de los agentes por los estados:
- Para cada agente, su estado actual (novato, experimentado, explorador o explotador) se determina con la ayuda de "switch". Dependiendo del estado, se llama al método correspondiente que controla el comportamiento del agente (por ejemplo, "StageActivityNovice", "StageActivityExperienced", etc.).
- Después de realizar acciones dependientes del estado, las posiciones de los agentes se actualizan usando el método "SeInDiSp" para permanecer dentro de los límites aceptables.
3. El ciclo actualiza el array "a" copiando las posiciones actuales de los agentes en los elementos correspondientes del array "a".
Sentido final del método "Moving", que controla el movimiento de los agentes en el algoritmo ABHA, consiste en inicializar primero las posiciones de los agentes si esta es la primera llamada al método, y luego actualizar sus posiciones dependiendo de su estado. Además, incluye:
- La generación de posiciones iniciales aleatorias.
- La determinación del comportamiento de los agentes según su estado.
- La actualización de las posiciones actuales de los agentes en el array "a".
Este método es el método clave y de control a la hora de llamar a otros métodos de estado de la abeja para el comportamiento dinámico de los agentes en el proceso de optimización.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::Moving () { //---------------------------------------------------------------------------- if (!revision) { double val = 0.0; for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { val = u.RNDfromCI (rangeMin [c], rangeMax [c]); val = u.SeInDiSp (val, rangeMin [c], rangeMax [c], rangeStep [c]); agents [i].position [c] = val; agents [i].bestPosition [c] = val; agents [i].direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); a [i].c [c] = val; } } revision = true; return; } //---------------------------------------------------------------------------- for (int i = 0; i < popSize; i++) { switch (agents [i].state) { //------------------------------------------------------------------------ //Novice case S_ABHA_Agent::stateNovice: { StageActivityNovice (agents [i]); break; } //------------------------------------------------------------------------ //Experienced case S_ABHA_Agent::stateExperienced: { StageActivityExperienced (agents [i]); break; } //------------------------------------------------------------------------ //Search case S_ABHA_Agent::stateSearch: { StageActivitySearch (agents [i]); break; } //------------------------------------------------------------------------ //Food source case S_ABHA_Agent::stateSource: { StageActivitySource (agents [i]); break; } } //-------------------------------------------------------------------------- for (int c = 0; c < coords; c++) { agents [i].position [c] = u.SeInDiSp (agents [i].position [c], rangeMin [c], rangeMax [c], rangeStep [c]); a [i].c [c] = agents [i].position [c]; } } for (int i = 0; i < popSize; i++) for (int c = 0; c < coords; c++) a [i].c [c] = agents [i].position [c]; } //——————————————————————————————————————————————————————————————————————————————
El método "Revision" de la clase "C_AO_ABHA" es el responsable de actualizar el estado de los agentes en el algoritmo y realiza varias acciones clave relacionadas con la evaluación y actualización de las posiciones y estados de los agentes. El método "Revision" no adopta parámetros y no retorna ningún valor. Sirve para actualizar la información sobre el estado de los agentes y sus posiciones en función del rendimiento. Lógica del método:
1. Búsqueda del mejor agente:
- La variable "ind" se inicializa a "-1" para realizar un seguimiento del índice del agente con el mejor coste.
- Búsqueda del mejor agente; el ciclo pasa por todos los agentes "popSize":
- Si el coste del agente "a[i].f" es mayor que el máximo actual "fB", se actualiza "fB" y se almacena el índice "ind".
- Si se encuentra un agente con el mejor coste (es decir, "ind" no será igual a "-1"), se llamará a la función "ArrayCopy", que copiará las coordenadas del mejor agente en el array "cB".
2. El ciclo pasa por todos los agentes y actualiza su coste "agents[i].cost" en función de los valores del array "a".
3. Se llama al método "CalculateProbabilities", que calcula las probabilidades para cada agente en función de sus costes actuales. Esto se usa para determinar cómo actuarán los agentes en el siguiente paso.
4. Se llama al método "CalculateAverageCost", que calcula el coste promedio de todos los agentes, necesario para que las abejas analicen su propio estado y pasen a nuevos estados.
5. El ciclo pasa por todos los agentes y, dependiendo de su estado actual, llama al método correspondiente para cambiar el estado del agente "ChangingStateForNovice", "ChangingStateForExperienced", etc.
6. El ciclo pasa por todos los agentes y verifica si el coste actual del agente es mayor que su mejor coste "bestCost":
- De ser así, se actualiza "bestCost" y la posición actual del agente se copia a "bestPosition".
- El coste anterior "prevCost" se actualiza al valor actual "cost".
Sentido final del método "Revision", encargado de actualizar la información sobre el estado de los agentes en el algoritmo y realizar las siguientes acciones clave:
1. Encuentra el agente con el mejor coste y actualiza las variables correspondientes.
2. Actualiza los costes de todos los agentes.
3. Calcula probabilidades basadas en los costes actuales.
4. Calcula el coste promedio de los agentes.
5. Actualiza los estados del agente en función de su rendimiento.
6. Actualiza los mejores costes y posiciones de los agentes.
Este método supone una parte importante del algoritmo, ya que ayuda a los agentes adaptarse según su éxito y les permite intercambiar información.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::Revision () { //---------------------------------------------------------------------------- int ind = -1; for (int i = 0; i < popSize; i++) { if (a [i].f > fB) { fB = a [i].f; ind = i; } } if (ind != -1) ArrayCopy (cB, a [ind].c, 0, 0, WHOLE_ARRAY); //---------------------------------------------------------------------------- for (int i = 0; i < popSize; i++) agents [i].cost = a [i].f; //---------------------------------------------------------------------------- //Calculate the probabilities for bees at the current cost CalculateProbabilities (); //---------------------------------------------------------------------------- //Calculate the average cost CalculateAverageCost (); //---------------------------------------------------------------------------- //update bees' states (novice, experienced, search, source) for (int i = 0; i < popSize; i++) { switch (agents [i].state) { case S_ABHA_Agent::stateNovice: { ChangingStateForNovice (agents [i]); break; } case S_ABHA_Agent::stateExperienced: { ChangingStateForExperienced (agents [i]); break; } case S_ABHA_Agent::stateSearch: { ChangingStateForSearch (agents [i]); break; } case S_ABHA_Agent::stateSource: { ChangingStateForSource (agents [i]); break; } } } //---------------------------------------------------------------------------- //Update the cost for bees for (int i = 0; i < popSize; i++) { if (agents [i].cost > agents [i].bestCost) { agents [i].bestCost = agents [i].cost; ArrayCopy (agents [i].bestPosition, agents [i].position); } agents [i].prevCost = agents [i].cost; } } //——————————————————————————————————————————————————————————————————————————————
Conclusión
En este artículo nos hemos familiarizado con el algoritmo de colmena ABHA, hemos analizado con detalle sus principios de funcionamiento, hemos escrito el pseudocódigo del algoritmo y también hemos descrito su estructura, su clase, su inicialización y sus métodos "Moving" y "Revision". En el próximo artículo continuaremos escribiendo el código del algoritmo y abarcaremos todos los demás métodos y, como de costumbre, realizaremos tests con las funciones de prueba, resumiendo los resultados del algoritmo en la tabla de calificación.
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/15347
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.
Integración de MQL5 con paquetes de procesamiento de datos (Parte 2): Aprendizaje automático (Machine Learning, ML) y análisis predictivo
Gestión de Riesgo (parte 3): Construyendo la Clase Principal para la Gestión de Riesgo
Redes neuronales en el trading: Inyección de información global en canales independientes (InjectTST)
Reimaginando las estrategias clásicas (Parte VI): Análisis de múltiples marcos temporales
- 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