Optimización del modelo de nubes atmosféricas — Atmosphere Clouds Model Optimization (ACMO): Teoría

Contenido

1. Introducción
2. Implementación del algoritmo

Introducción

En el mundo de la tecnología moderna, encontrar las mejores soluciones para los algoritmos de optimización se ha convertido en una tarea cada vez más importante. Una de las aproximaciones más interesantes a este problema es el algoritmo metaheurístico Atmosphere Clouds Model Optimisation (ACMO), que, a pesar de su complejidad matemática, puede explicarse de forma clara y simple. 

Imagine un inmenso cielo virtual en el que las nubes se forman y se desplazan como en una atmósfera real. El tiempo aquí no supone solo un conjunto de condiciones, sino un sistema vivo en el que la humedad y la presión atmosférica influyen en cada decisión. Inspirado en fenómenos naturales, el algoritmo ACMO usa los principios de la formación de nubes para explorar el espacio de soluciones, del mismo modo que las nubes se forman, se extienden y desaparecen en la extensión celeste, en un esfuerzo por encontrar caminos óptimos. El algoritmo fue propuesto por los autores Yang y otros, y publicado en 2013.

En este artículo, detallaremos cada paso del algoritmo ACMO, empezando por la preparación del "cielo" donde nacen las nubes como soluciones potenciales. Luego seguiremos su movimiento por el cielo virtual, observando cómo se adaptan y cambian en función de las condiciones meteorológicas. Al sumergirse en este fascinante proceso, verá cómo las nubes, semejantes a equipos de investigación, se esfuerzan por encontrar soluciones óptimas en un laberinto de posibilidades. Juntos desvelaremos los misterios de este algoritmo y comprenderemos cómo funciona, paso a paso.

La idea principal del algoritmo Atmosphere Clouds Model Optimisation (ACMO, en lo sucesivo) consiste en modelar el comportamiento de las nubes en la naturaleza para resolver problemas de optimización. El algoritmo explota tres aspectos clave del comportamiento de las nubes:

• Generación. Las nubes se forman en regiones de alta humedad, lo cual permite al algoritmo explorar la vecindad de las soluciones óptimas actuales.
• Movimiento. Las nubes se desplazan por el espacio de soluciones, lo cual ayuda a que la población se extienda y aumente su diversidad. Y esto ayuda a evitar el atasco en óptimos locales.
• Dispersión. Las nubes se dispersan por el espacio de búsqueda, lo cual permite al algoritmo abarcar una gama de posibles soluciones más amplia y mejorar las posibilidades de encontrar un óptimo global.

Implementación del algoritmo

Como el concepto del algoritmo ACMO es bastante complejo de entender, iremos de lo simple a lo complejo. Vamos a describir la idea básica del algoritmo de la forma más sencilla posible.

1. Preparamos el "cielo". Imaginemos que estamos creando un cielo virtual. Este cielo está dividido en muchas regiones. Cada región posee su propia humedad (calidad de las soluciones) y presión atmosférica (experiencia acumulada en la búsqueda).

2. Nacimiento de las nubes. Las nubes solo aparecen en las regiones más "húmedas". Cada nube está formada por muchas gotas, y cada gota supone una solución potencial a nuestro problema.

3. Movimiento de las nubes. Las nubes casi nunca se quedan quietas. Pasan de regiones de alta presión a regiones de baja presión. Esto es similar a la forma en que el viento sopla de una región de alta presión a una región de baja presión en la atmósfera real.

4. Forma cambiante de las nubes. A medida que las nubes se desplazan, se hacen más grandes. El grado de aumento del tamaño de las nubes dependerá de la diferencia de presión entre las regiones.

5. Evaporación. A cada paso las nubes pierden una parte de sus gotas y al perder humedad su humedad disminuye. Si hay muy poca humedad en una nube, esta desaparecerá por completo.

6. Actualización del "tiempo". Después de cada movimiento de las nubes, se revisa la humedad y la presión en cada región. Si la nube ha encontrado una buena solución, la humedad en esa región aumentará.

7. Repetición. Los pasos del 2 al 6 se repiten. Con cada repetición, las nubes exploran cada vez más zonas del cielo virtual en busca de la mejor solución.

8. Finalización. Tras completar un número determinado de repeticiones o encontrar una solución suficientemente buena, el algoritmo se detendrá.

Este algoritmo es como si enviáramos a muchos equipos de investigación (las nubes) a buscar un tesoro (la solución óptima) en un enorme laberinto (el espacio de búsqueda). Cada grupo busca a su manera, comparte información con los demás a través del "clima" cambiante de las regiones y, poco a poco, todos juntos encuentran el mejor camino.

Figura 1. Nubes de diferente densidad, humedad y tamaño sobre las regiones. La caída de gotas obedece a una distribución normal.

En primer lugar, nos familiarizaremos con los parámetros externos de ACMO y su finalidad usando la tabla siguiente.

Parámetro	Asignación de parámetros
popSize - tamaño de la población	Tamaño de la población de gotas; la población de tamaño fijo y las gotas se distribuyen en nubes
cloudsNumber - número de nubes	Número de nubes
regionsNumber - número de regiones	Cada parámetro optimizado se divide en el mismo número de regiones
dMin - número mínimo de gotas	Número mínimo de gotas en relación con el número medio de gotas en las nubes. Umbral por debajo del cual una nube se considera seca
λ - factor de umbral	Factor de umbral de humedad de la región en la que puede formarse una nube con generación de lluvia (gotas)
γ - factor de secado	El factor de secado reduce la cantidad de humedad de las nubes en cada iteración.
EnM0 - entropía inicial	Entropía inicial - anchura de la nube en el momento de su aparición
HeM0 - hiperentropía inicial	La hiperentropía, la densidad de una nube cuando aparece, rige la forma de la distribución normal

Veamos ahora los pasos del algoritmo ACMO.

1. Inicialización:

• Partición del espacio de búsqueda U en regiones MD regiones Ui.
• Inicialización de los valores de humedad HUi y presión atmosférica PUi para cada región.
• Ajuste de los parámetros del algoritmo: el factor de umbral λ, el factor de secado γ, la entropía inicial EnM0, la hiperentropía inicial HeM0, etc.

2. Generación de nubes:

• Determinación del conjunto de regiones S en las que la humedad HUi supera el umbral Ht calculado dinámicamente.
• Para cada región Ui de S:
• Cálculo del centro de la nube CenterCk usando la fórmula CenterCk = Center (Ui).
• Cálculo de la entropía EnCk y la hiperentropía HeCk a partir de la entropía inicial EnM0, HeM0 y el coeficiente de contracción ζ.
• Generación de una nube Ck con centroCk, entropía EnCk e hiperentropía HeCk.

3. Actualización de la humedad y la presión:

• Actualización de los valores de humedad HUi y presión atmosférica PUi para cada región Ui.

4. Fase de movimiento de las nubes:

• Para cada nube Ck:
• Se determina la dirección del movimiento de las nubes en función de la diferencia de presión atmosférica entre la región actual y una región vecina seleccionada.
• La nube Ck se desplaza en la dirección de la presión atmosférica más baja.

5. Fase de propagación de las nubes:

• Para cada nube Ck:
• Se determina qué gotas de nubes se extienden a otras regiones en función de las diferencias de presión atmosférica.
• Propagación de gotas de nubes Ck a regiones vecinas con menor presión atmosférica.

6. Actualización de la humedad y la presión:

• Actualización de los valores de humedad HUi y presión atmosférica PUi para cada región Ui tras el movimiento y la propagación de las nubes.

7. Verificación de la condición de finalización:

• Aumento del contador de iteraciones t.
• Si t < tmax, se pasa al paso 2 (generación de nubes).
• Si t >= tmax, el algoritmo finalizará.

Puntos clave:

• Las regiones Ui forman el espacio de búsqueda, cada región se caracteriza por la humedad HUi y la presión atmosférica PUi.
• Las nubes Ck solo se generan en regiones con suficiente humedad (HUi > Ht).
• El movimiento y la propagación de las nubes están influidos por las diferencias de presión atmosférica entre regiones.
• Los valores de humedad y presión se actualizan tras cada ciclo de movimiento y propagación de las nubes.

Vamos a centrarnos ahora en las principales operaciones en la nube con más detalle.

1. La operación Cloudmove (C) se encarga de desplazar las nubes.

1.1 Para cada nube Ck:

• Se selecciona una región objetivo aleatoria F del espacio de búsqueda U.
• Se calcula la diferencia de presión ΔP entre la zona actual E, donde se encuentra la nube, y la zona objetivo F.
• Si la presión en F es menor que en E (ΔP > 0), la nube Ck se desplazará hacia la región de menor presión.
• La velocidad de la nube Vk se calcula a partir de la diferencia de presión y la entropía de la nube.
• El centro de la nube Ck se desplaza una distancia Vk.
• La cantidad de humedad en la nube Ck disminuye en γ * 100% debido a la evaporación.
• Si el número de gotas nk es inferior al valor umbral dN, la nube Ck se eliminará del conjunto de nubes C (de hecho, la nube no se elimina, sino que se desplaza a regiones con una humedad superior al valor umbral con el establecimiento de valores iniciales de entropía e hiperentropía corregidos para la iteración actual).

Así, las nubes se desplazan hacia zonas de menor presión, mientras que su energía (cantidad de humedad) disminuye gradualmente. Este mecanismo de movimiento refleja el comportamiento físico de las nubes en la naturaleza.

2. La operación Cloudspread (C) se ocupa de la propagación de las nubes.

2.1 Para cada nube Ck:

• Se obtiene la región actual E en la que se encuentra el centro de la nube.
• Se obtiene la región G a la que se desplazará el centro de la nube tras la fase de movimiento.
• Se calcula la diferencia de presión ΔP = PE - PG entre la región actual y la nueva.
• Si las regiones E y G son diferentes, se calculará el factor de propagación α = ΔP / ΔPmax.
• Si las regiones E y G coinciden, se establecerá en α = 0.3 (tasa de propagación básica).
• Se calcula la nueva entropía de la nube EnCk = EnCk × (1 + α), donde α es el factor de propagación.
• Se calcula la nueva hiperentropía de la nube HeCk = HeCk × (1 + α), es decir, aumenta en proporción al factor de propagación.
• Si la entropía de la nube Ck es superior a 5 × EnM0 o la cantidad de humedad que contiene es inferior a un valor umbral dN, la nube Ck "se eliminará" del conjunto C.

Ideas principales de las operaciones 1 y 2:

• Cuanto mayor sea la diferencia de presión entre las regiones, más rápido se desplazarán las nubes.
• La entropía aumenta para ampliar el área del espacio de búsqueda.
  
• La hiperentropía de la nube aumenta para facilitar una exploración más exhaustiva del espacio.
• Criterios de disipación de las nubes: entropía superior a 5 × EnM0 o cantidad de humedad inferior a dN.

En la descripción del algoritmo, los autores no especifican ninguna limitación sobre el número de regiones que puede abarcar una nube. El algoritmo solo tiene en cuenta dos regiones: la región actual E, donde se encuentra el centro de la nube Ck, y la nueva región G (el nuevo centro tras el desplazamiento). Sin embargo, las nubes aumentan de tamaño en cada iteración, apoderándose de las regiones vecinas, lo cual provoca un aumento de la humedad y la presión en las zonas donde caen las gotas. Así, una misma nube puede desplazarse secuencialmente de una región a otra, pero en un momento dado, el algoritmo solo operará en dos regiones, la actual y la nueva. Esto significa que los procesos de desplazamiento de las nubes y de precipitación regional de las gotas se consideran por separado. Las nubes y las gotas no están relacionadas entre sí y representan entidades diferentes dentro del algoritmo.

El algoritmo actualiza la posición de la nube, calcula la nueva entropía e hiperentropía y comprueba si la nube supera los criterios de disipación, pero no impone explícitamente restricciones sobre el número de regiones que puede abarcar.

Figura 2. Movimiento regional de las nubes hacia las presiones bajas.

De la descripción del algoritmo se desprende que la región, y no la nube, tiene una "función de aptitud", a saber, la humedad de la región. El papel de la nube en este algoritmo es más bien el de un indicador que muestra cuántas gotas caerán en una región determinada. Puntos clave:

1. Una región tiene su propia presión P, que determina la velocidad de propagación de las nubes.
2. La nube Ck no "posee" las gotas, sino que sirve como indicador para mostrar cuántas gotas caerán en la región actual E y en la nueva región G.
3. El desplazamiento de las nubes de la región E a la región G viene determinado por el gradiente de presión ΔP = PE - PG.
4. Las gotas no pertenecen a una nube concreta, sino que caen en las regiones donde se hallan las nubes.

Así pues, la región, y no la nube, es la principal entidad que determina la dinámica del "tiempo" en un sistema específico. Cabe destacar que esta es la diferencia entre este algoritmo y los algoritmos multipoblación.

La presión es una característica importante de cada región del espacio de búsqueda y se usa para determinar la dirección del movimiento de las nubes, es decir, las nubes se desplazan de las regiones de alta presión a las de baja presión. Conceptualmente, la presión en una región aumenta cada vez que se valora la región (cuando se calcula el valor de la función objetivo para un punto de esa región). Esto refleja la idea de que cuanto más exploremos una zona concreta, mayor será la "presión" en esa zona, lo que animará al algoritmo a explorar otras zonas menos exploradas.

Según el algoritmo de los autores, el cambio de forma de la nube se produce según la diferencia de presión atmosférica entre la región actual donde se encuentra la nube y la nueva región a la que se desplaza. Concretamente, esto ocurre de la forma siguiente:

• Si la diferencia de presión ΔP = PE - PG es grande, esto significa que la nube se desplaza desde una región con una presión muy diferente y la velocidad de la nube será mayor.
• Si la diferencia de presión ΔP es pequeña, significará que la nube se desplaza a una región con un valor de presión cercano y una velocidad baja.

A continuación, según la descripción del algoritmo, los valores de entropía e hiperentropía en la primera iteración se determinarán del siguiente modo:

1. Entropía inicial EnM0 = Ij / A, donde:

• A establecido en el nivel 6
• Ij - longitud del área en la j-ésima dimensión

2. La hiperentropía inicial de HeM0 se fija en 0,5.

La entropía del algoritmo determina la extensión (tamaño) de la nube. En la primera iteración, la nube debe abarcar al menos una región de búsqueda completa.

La hiperentropía es responsable del "espesor" de la nube y rige la forma de la distribución normal o, en otras palabras, la densidad con la que se disponen las gotas en la nube. El valor inicial 0,5 se ha elegido experimentalmente como equilibrio entre una nube demasiado fina y otra demasiado densa.

1. La entropía aumenta con cada iteración. Esto significa que las nubes se "estiran" gradualmente para abarcar áreas de búsqueda cada vez mayores y ayuda a evitar el atasco en óptimos locales.
2. La hiperentropía, por el contrario, aumenta la densidad en el centro de la nube. Esto hace que la nube afine la solución de una región con perspectivas.

Este enfoque permite al algoritmo afinar las soluciones simultáneamente con la expansión del área de búsqueda y seguir conservando la capacidad de "escapar" de los óptimos locales.

En un espacio multidimensional, la determinación del índice de región de una nube se complica un poco, pero el principio sigue siendo el mismo. Así es como funciona:

• El espacio de búsqueda se divide en regiones a lo largo de todas las dimensiones. Si tenemos D mediciones y cada medición se divide en M intervalos, entonces tendremos un total de M × D regiones.
• En este caso, el índice de una región no será solo un número, sino un conjunto de coordenadas que muestran la posición de la región a lo largo de cada dimensión. Para determinar el índice de región de una nube, el algoritmo comprobará en qué intervalos de cada dimensión se encuentra el centro de la nube.

Por ejemplo, si tenemos un espacio tridimensional (D = 3) dividido en 10 intervalos a lo largo de cada dimensión (M = 10), el índice de región podría parecerse a (3, 7, 2), lo que implica el intervalo 3 a lo largo de la primera dimensión, el intervalo 7 a lo largo de la segunda y el intervalo 2 a lo largo de la tercera.

Debemos prestar atención al centro de la nube, que no es necesariamente la mejor gota de la nube. He aquí algunos puntos importantes:

• El centro de la nube se define como un cierto "punto medio" de la región en la que se genera la nube.
• La mejor gota en la nube será la que ofrezca el mejor valor de la función objetivo (el valor de aptitud más alto).
• En el algoritmo, existe el concepto de "valor de humedad de la región" (UiH) que representa el mejor valor de adaptabilidad encontrado en una región determinada. Este valor se refiere a la mejor gota, no al centro de la nube.
• El centro de la nube sirve para determinar su posición en el espacio de búsqueda y calcular su movimiento, pero no se corresponde necesariamente con la mejor solución.

Por ello, el centro de la nube y la mejor gota son conceptos diferentes en este algoritmo. El centro se usa para navegar por la nube en el espacio de búsqueda, mientras que la mejor gota representa la solución de mayor optimalidad encontrada en la región en ese momento.

Este enfoque permite al algoritmo explorar con eficacia el espacio de búsqueda (utilizando el centro de la nube para el movimiento), al tiempo que rastrea y almacena las mejores soluciones encontradas en las regiones (las mejores gotas caídas en las regiones).

Existen varios casos en el algoritmo ACMO en los que se produce la aniquilación o "disolución" de nubes. Vamos a desglosarlos:

1. Humedad insuficiente:

• Cada nube posee una cierta cantidad de humedad.
• Si la cantidad de humedad resulta inferior al valor umbral dN, la nube se considerará demasiado seca y desaparecerá.
• Esto es similar a la manera en que las pequeñas nubes se dispersan en la naturaleza.

2. Demasiada entropía:

• La entropía de una nube muestra lo extendida que está.
• Si la entropía es superior a 5 veces la entropía inicial (5 × EnM0), la nube se considerará demasiado difusa y desaparecerá.

Podemos considerar esto una nube que se ha estirado tanto que simplemente se disuelve en el aire.

3. Evaporación natural:

• Después de cada movimiento de la nube, su humedad disminuye en un determinado porcentaje (γ * 100%).
• Si la cantidad de humedad es inferior a dN tras esta reducción, la nube desaparecerá.

Esto resulta similar a la evaporación gradual de una nube en la naturaleza.

4. Fusión de nubes:

• Aunque esto tampoco se describe explícitamente en este algoritmo, las nubes pueden fusionarse en algunas variantes de ACMO.
• Al darse la fusión entre nubes, podemos considerar que una de las nubes (normalmente la más pequeña) ha desaparecido, pasando a formar parte de la nube mayor.

Todos estos mecanismos de eliminación de nubes ayudan al algoritmo a "limpiar" el espacio de búsqueda de soluciones poco prometedoras y centrarse en las áreas más prometedoras. 

Un investigador atento podría preguntarse: ¿qué ocurre si las nubes empiezan a desplazarse hacia una región de bajas presiones y se reúnen todas juntas en las mismas regiones? En primer lugar, las regiones de baja presión no son las peores soluciones del espacio de búsqueda: son simplemente zonas poco exploradas. Incluso si todas las nubes se concentren en las regiones con menor presión, la presión en esas zonas comenzarán a aumentar gradualmente. En algún momento, esto dará lugar a nuevas regiones de menor presión, lo que inevitablemente obligará a las nubes a abandonar su ubicación actual.

De esta forma, las nubes nunca permanecen mucho tiempo en su sitio y se mueven tanto en el terreno de las soluciones de calidad como en el de las menos prometedoras. Además, los mecanismos de evaporación de las nubes y de expansión continua de las mismas seguida de su destrucción permiten la creación de nuevas nubes que sustituyen a las destruidas en las buenas regiones. Así se inicia un nuevo ciclo de perfeccionamiento de las áreas con perspectivas del espacio de búsqueda.

Determinación del centro de la nueva nube Ck. Si el valor de humedad de la región supera el umbral, puede generar una nueva nube. El valor umbral de humedad Ht se calcula dinámicamente mediante la ecuación:

Ht = Hmin + λ * (Hmax - Hmin), donde:

• Hmin y Hmax son los valores mínimo y máximo de humedad en toda la zona de búsqueda, respectivamente
• λ es el factor de umbral igual a 0,7 basado en pruebas experimentales

Cálculo de la entropía y la hiperentropía. El valor de entropía de las nuevas nubes EnMdisminuye durante el proceso de búsqueda y viene dado por la fórmula:

EnMt = ζ * EnM0, donde ζ es la relación de compresión, que se calcula mediante la fórmula:

ζ = 1 / (1 + e^(- (8 - 16 * (t / tmax))))

La hiperentropía de las nubes recién generadas aumenta con cada iteración:

HeMt = ζ * HeM0, donde ζ es el coeficiente de expansión, que se calcula mediante la fórmula:

ζ = 1 / (1 + e^(8 - 16 * (t / tmax))), donde:

• EnM0j es una entropía inicial igual a 0,2
  
• HeM0 es una hiperentropía inicial igual a 0,5
• t es la iteración actual
• tmax es el número máximo de iteraciones

Figura 3. Gráficos de entropía e hiperentropía de las nubes nuevas según la época actual.

La velocidad de la nube obedece a la siguiente ley:

Vk = β * EnCk, donde β se expresa según la ecuación:

β = (PCk - PF) / (PMax - PMin), donde:

• β es el factor de presión atmosférica
• PMax y PMin son la presión atmosférica máxima y mínima en el espacio de búsqueda
  
• PCk y PF son la presión en la región actual y en la región objetivo
• EnCk es la entropía actual de la nube
  

Ahora que conocemos toda la teoría del modelo de movimiento de nubes atmosféricas ACMO, procederemos a escribir el código del algoritmo.

Describiremos la estructura "S_ACMO_Region", que se utiliza para representar una región con características meteorológicas. La estructura "S_ACMO_Region" contiene varios campos, cada uno de los cuales guarda información sobre la región:

Campos de la estructura:

• humidity - nivel de humedad de la región.
• pressure - presión atmosférica en la región.
• centre - centro de la región como un vector de coordenadas que denota el punto central.
• x - indica el punto de mayor presión de la región.

Init() - método de inicialización que establece los valores iniciales de los campos de la estructura.

• humidity - se inicializa con el valor "-DBL_MAX", que indica un nivel de humedad extremadamente bajo.
• pressure - se inicializa con cero, porque la presión no se ha medido todavía.

La estructura "S_ACMO_Region" se usa en un modelo meteorológico en el que es necesario almacenar y procesar información sobre diferentes regiones según sus condiciones climáticas. El método "Init ()" garantiza que la estructura se inicialice correctamente antes de su uso. 

//——————————————————————————————————————————————————————————————————————————————
// Region structure
struct S_ACMO_Region
{
    double humidity; //humidity in the region
    double pressure; //pressure in the region
    double centre;   //the center of the region
    double x;        //point of highest pressure in the region

    void Init ()
    {
      humidity = -DBL_MAX;
      pressure = 0;
    }
};
//——————————————————————————————————————————————————————————————————————————————

A continuación, describiremos dos estructuras: "S_ACMO_Area" y "S_ACMO_Cloud" y analizaremos con detalle:

 1. La estructura "S_ACMO_Area" representa una región formada por un array de regiones que se describen mediante la estructura "S_ACMO_Region" y contienen información sobre varias regiones de esta área.

 2. La estructura "S_ACMO_Cloud" representa la nube y sus características. Campos de la estructura:

• centro [] - array que almacena las coordenadas del centro de la nube.
• entropy [] - array de valores de entropía de la nube para cada coordenada.
  
• entropyStart [] - array de valores iniciales de entropía.
• hiperEntropy - valor de hiperentropía.
  
• regionIndex [] - array de índices de las regiones a las que pertenecen las nubes.
• droplets - número de gotitas en una nube (concepto convencional que denota la humedad de la nube).

El método "Init (int coords)" inicializa los arrays en la estructura, cambiando su tamaño en función del parámetro "coords" transmitido.

Ambas estructuras se usan en el modelo meteorológico para representar y analizar regiones y nubes. "S_ACMO_Area" se utiliza para agrupar regiones y "S_ACMO_Cloud" para describir las características de las nubes.

//——————————————————————————————————————————————————————————————————————————————
struct S_ACMO_Area
{
    S_ACMO_Region regions [];
};
//——————————————————————————————————————————————————————————————————————————————

//——————————————————————————————————————————————————————————————————————————————
// Cloud structure
struct S_ACMO_Cloud
{
    double center       [];    // cloud center
    double entropy      [];    // entropy
    double entropyStart [];    // initial entropy
    double hyperEntropy;       // hyperEntropy
    int    regionIndex  [];    // index of regions
    double droplets;           // droplets

    void Init (int coords)
    {
      ArrayResize (center,       coords);
      ArrayResize (entropy,      coords);
      ArrayResize (entropyStart, coords);
      ArrayResize (regionIndex,  coords);
      droplets = 0.0;
    }
};
//——————————————————————————————————————————————————————————————————————————————

Vamos a analizar la clase "C_AO_ACMO", que hereda de otra clase "C_AO". Estructura general de la clase:

1. Parámetros de clase que cumplen el papel de parámetros externos del algoritmo:

• popSize - tamaño de la población.
• cloudsNumber - número de nubes.
• regionsNumber - número de regiones por dimensionalidad.
• dMin - número mínimo de gotas en relación con el número medio de gotas en las nubes.
• EnM0 y HeM0 - valores iniciales de entropía e hiperentropía.
• λ - factor de umbral para definir las regiones lluviosas.
• γ - tasa de atenuación.

2. Conjunto de parámetros:

• params - array de estructuras donde cada elemento contiene el nombre y el valor del parámetro.

3.  Métodos:

• SetParams () - establece los parámetros del modelo a partir de el array "params".
• Init () - inicializa el modelo con los límites de búsqueda, el paso y el número de épocas especificados.
• Moving () - método responsable del movimiento de las nubes.
• Revision () - método que realiza una revisión del estado del modelo.
• MoveClouds () - método responsable de desplazar las nubes.
• GetRegionIndex () - método para obtener el índice de región de un punto dado.
• RainProcess() - método responsable del proceso de lluvia.
• DropletsDistribution () - método para distribuir gotas a las nubes.
• UpdateRegionProperties () - método para actualizar las propiedades de las regiones.
• GenerateClouds () - método para generar nubes.
• CalculateHumidityThreshold () - método para calcular el umbral de humedad.
• CalculateNewEntropy () - método para calcular la nueva entropía de una nube.

4. Miembros de la clase:

   S_ACMO_Area areas [] - array de áreas que contiene información sobre diferentes regiones.

   S_ACMO_Cloud clouds [] - array de nubes que contiene información sobre las características de las nubes.

   Se usan variables privadas como "epochs", "epochNow", "dTotal", "entropy []" y "minGp" para seguir el estado del modelo y los cálculos.

La clase "C_AO_ACMO" está destinada a la modelación y el movimiento de las nubes en la atmósfera, e incluye varios parámetros y métodos para gestionar el estado, el movimiento y la interacción de las nubes con las regiones.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_ACMO : public C_AO
{
  public: //--------------------------------------------------------------------
  ~C_AO_ACMO () { }
  C_AO_ACMO ()
  {
    ao_name = "ACMO";
    ao_desc = "Atmospheric Cloud Model Optimization";
    ao_link = "https://www.mql5.com/es/articles/15849";

    popSize       = 50;    //population size

    cloudsNumber  = 5;     // Number of clouds
    regionsNumber = 10;    // Number of regions per dimension  (M)
    dMin          = 0.2;   // Minimum number of drops relative to the average number of drops in the clouds (dN)
    EnM0          = 1.0;   // Initial value of entropy
    HeM0          = 0.5;   // Initial value of hyperentropy
    λ             = 0.7;   // Threshold factor (threshold of the rainiest regions)
    γ             = 0.2;   // Weaken rate

    ArrayResize (params, 8);

    params [0].name = "popSize";       params [0].val = popSize;

    params [1].name = "cloudsNumber";  params [1].val = cloudsNumber;
    params [2].name = "regionsNumber"; params [2].val = regionsNumber;
    params [3].name = "dMin";          params [3].val = dMin;
    params [4].name = "EnM0";          params [4].val = EnM0;
    params [5].name = "HeM0";          params [5].val = HeM0;
    params [6].name = "λ";             params [6].val = λ;
    params [7].name = "γ";             params [7].val = γ;
  }

  void SetParams ()
  {
    popSize       = (int)params [0].val;

    cloudsNumber  = (int)params [1].val;
    regionsNumber = (int)params [2].val;
    dMin          = params      [3].val;
    EnM0          = params      [4].val;
    HeM0          = params      [5].val;
    λ             = params      [6].val;
    γ             = params      [7].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    cloudsNumber;  // Number of clouds
  int    regionsNumber; // Number of regions per dimension (M)
  double dMin;          // Minimum number of drops relative to the average number of drops in the clouds (dN)
  double EnM0;          // Initial value of entropy
  double HeM0;          // Initial value of hyperentropy
  double λ;             // Threshold factor
  double γ;             // Weaken rate


  S_ACMO_Area   areas  [];
  S_ACMO_Cloud  clouds [];

  private: //-------------------------------------------------------------------
  int    epochs;
  int    epochNow;
  int    dTotal;         // Maximum total number of droplets (N)
  double entropy [];     // Entropy
  double minGp;          // Minimum global pressure


  void   MoveClouds                 (bool &rev);
  int    GetRegionIndex             (double point, int ind);
  void   RainProcess                (bool &rev);
  void   DropletsDistribution       (double &clouds [], int &droplets []);

  void   UpdateRegionProperties     ();

  void   GenerateClouds             ();
  double CalculateHumidityThreshold ();
  void   CalculateNewEntropy        (S_ACMO_Cloud &cl, int t);
};
//——————————————————————————————————————————————————————————————————————————————

A continuación, analizaremos el método "Init" de la clase "C_AO_ACMO", que se ocupa de inicializar los parámetros del modelo de nube.

1. El método adopta tres arrays "rangeMinP", "rangeMaxP" y "rangeStepP" que describen los límites y pasos de los parámetros del modelo. El cuarto parámetro es "epochsP", por defecto es igual a 0 y especifica el número de épocas.

2. Llama al método "StandardInit" para ejecutar la inicialización básica. Si no tiene éxito, el método retornará "false".

3. Inicialización de variables: el método establece el número total de épocas y restablece la época actual a 0.

4. Inicialización de parámetros:

• dTotal - se establece igual al tamaño de la población.
• dMin - se recalcula para tener en cuenta la relación entre el tamaño de la población y el número de nubes.

5. Asignación de memoria a los arrays: el método redimensiona los arrays "entropy" y "areas" en función del número de coordenadas.

6. Inicialización de la entropía y las regiones:

• para cada coordenada "c" se calcula el valor de entropía.
• para cada región "r", se llama al método "Init ()" para inicializar la región.
• el centro de la región se calcula como el valor medio entre los valores mínimo y máximo multiplicado por el número de regiones.
• entonces el centro pasa por el método "SeInDiSp", que se ocupa de normalizar los valores con el rango especificado.
• establece la coordenada "x" de la región (el valor más alto de humedad, por defecto estará en el centro de la región).
  

7. Inicialización de la nube:

• redimensiona el array "clouds" en función del número de nubes.
• El método "Init" se llama para cada nube e inicializa los parámetros.

El método "Init" ejecuta la configuración básica y la inicialización del modelo de nube, estableciendo los parámetros, los tamaños de array y los valores necesarios para la simulación posterior. Está estructurado para realizar primero la inicialización estándar de la clase padre y después configurar los parámetros específicos relacionados con las coordenadas, regiones y nubes.

//——————————————————————————————————————————————————————————————————————————————
bool C_AO_ACMO::Init (const double &rangeMinP  [],
                      const double &rangeMaxP  [],
                      const double &rangeStepP [],
                      const int     epochsP = 0)
{
  if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false;

  //----------------------------------------------------------------------------
  epochs   = epochsP;
  epochNow = 0;

  //----------------------------------------------------------------------------
  dTotal       = popSize;
  dMin         = dMin * (popSize / (double)cloudsNumber);

  ArrayResize (entropy, coords);
  ArrayResize (areas,   coords);

  for (int c = 0; c < coords; c++)
  {
    entropy [c] = (rangeMax [c] - rangeMin [c]) / regionsNumber;

    ArrayResize (areas [c].regions, regionsNumber);

    for (int r = 0; r < regionsNumber; r++)
    {
      areas [c].regions [r].Init ();
      areas [c].regions [r].centre = rangeMin [c] + entropy [c] * (r + 0.5);
      areas [c].regions [r].centre = u.SeInDiSp (areas [c].regions [r].centre, rangeMin [c], rangeMax [c], rangeStep [c]);
      areas [c].regions [r].x      = areas [c].regions [r].centre;
    }
  }

  ArrayResize (clouds, cloudsNumber);
  for (int i = 0; i < cloudsNumber; i++) clouds [i].Init (coords);

  minGp = DBL_MAX;

  return true;
}
//——————————————————————————————————————————————————————————————————————————————

Conclusiones

En este artículo, nos hemos adentrado en el mundo del insólito y fascinante algoritmo ACMO, un modelo meteorológico atmosférico diseñado para resolver problemas de optimización multidimensional. Este algoritmo puede parecer multipoblacional a primera vista, pero un análisis más profundo revela su singularidad y novedad.

La base del modelo la forman tres entidades clave: nubes, regiones y gotas. Cada uno de estos componentes funciona de forma independiente, pero su interacción crea un sistema armonioso y eficaz en el que cada parte juega un papel importante. Las nubes simbolizan la diversidad de soluciones, las regiones representan los espacios de búsqueda y las gotas son elementos que realizan transiciones entre distintas soluciones. Esta combinación hace que el algoritmo ACMO no solo resulte original, sino que también suponga una herramienta muy potente en el campo de la optimización.

En la segunda parte de este artículo, daremos un paso más de la teoría a la práctica. Así, probaremos el algoritmo en varias funciones de prueba para evaluar su rendimiento e identificar sus puntos fuertes. Asimismo, extraeremos conclusiones, las analizaremos y quizás descubramos nuevos horizontes para aplicar este innovador modelo a tareas del mundo real.