Оптимизация атмосферными облаками — Atmosphere Clouds Model Optimization (ACMO): Практика

MetaTrader 5 — Тестер | 25 сентября 2024, 13:20

148

Andrey Dik

Содержание

Введение

В мире науки, где технологии и природа пересекаются, возникла уникальная идея метаэвристического алгоритма ACMO (Atmospheric Cloud Model Optimization) для оптимизации сложных задач. В предыдущей статье мы технически разобрали реализацию алгоритма, которая моделирует процесс формирования и движения облаков в атмосфере на основе различных метеорологических параметров. Что было проделано в первой части: мы создали класс для управления моделированием облаков, содержащий методы для инициализации, движения облаков, обновления свойств регионов и других процессов.

Мы разделили пространство поиска на регионы. Установили значения начальной влажности и давления в этих регионах. Задали параметры модели, такие как: начальная энтропия, гиперэнтропия, пороговое значение влажности для образования облаков и другие. Следующим этапом стала генерация облаков при выборе области с высокой влажностью. Произвели вычисление центра облака, энтропии и гиперэнтропии. Сделали обновление метеорологических параметров влажности и давления в регионах после генерации облаков. Реализовали перемещение облаков в области с низким давлением и последующее обновление характеристик облаков, в зависимости от их движения между регионами, а также рассеивание облаков.

Что еще осталось сделать? Реализовать функции для случайного размещения капель и их распределения между облаками. Завершить процесс дождя и обновление глобального решения. Провести тестирование модели на наших тестовых функциях с различными параметрами для оценки ее производительности и точности. Внесем изменения в процесс дождя и формирования капель для реализации более полноценного обмена информацией в популяции о перспективных регионах.

Реализация алгоритма

Опишем весь метеорологический процесс в виде псевдокода, что позволит нам на его основе собрать окончательную версию алгоритма:

1. На первой эпохе случайное размещение облаков:
   EnCk = EnM0;
   HeCk = HeM0;
//------------------------------------------------------------------------------
1.1 Движение облаков в сторону регионов с меньшим давлением:
   β = deltaP / normP
   d = Tck.x - Cck.c
   VC = β * d;
   Ck = Ck + VC

   изменение количества капель после движения:
   nk = nk × (1 - γ)

   изменение энтропии и гиперэнтропии:
   α = ΔP / ΔPmax;
   EnCk = EnCk * (1 + α)
   HeCk = HeCk * (1 - α)
//------------------------------------------------------------------------------
2. Процесс дождя, выпадение капель:
   распределение капель между облаками пропорционально влажности региона
   увеличение количества капель к существующим в облаках
//------------------------------------------------------------------------------
3. Расчет фитнес-функции для капель
//------------------------------------------------------------------------------
4. Обновление глобального решения и минимального давления в регионах, где выпадали капли
//------------------------------------------------------------------------------
5. Проверка на распад облаков и создание новых в регионах взамен распавшихся больше порога:
   правило распада в следствии расширения больше допустимого значения (разрыв облака):
   En > 5 * EnM0_t
   правило распада при содержании влаги ниже критического значения (высушивание облака):
   dCk < dMin

   пороговое значение, выше которого регионы могут образовать облака:
   HT = H_min + λ * (H_max - H_min);
//------------------------------------------------------------------------------
6. Энтропия и гиперэнтропия для новых облаков рассчитать:
   En = EnM0 / (1 + 2.72 ^ (-(8 - 16 * (t / maxT))))
   He = HeM0 / (1 + 2.72 ^ ((8 - 16 * (t / maxT))))

Итак, продолжим. Разберем метод "Moving" класса "C_AO_ACMO". Метод выполняет две операции: "MoveClouds (revision)" — отвечает за перемещение облаков, "RainProcess (revision)" — обрабатывает процесс дождя, который зависит от состояния облаков, а также от параметра "revision". Метод "Moving" выполняет два основных действия, связанных с динамикой облаков и процессом дождя. Он инкапсулирует логику перемещения облаков и их взаимодействия с процессом дождя. Таким образом, метод "Moving" служит для обновления состояния облаков и дождя в рамках симуляции погоды.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ACMO::Moving ()
{
  MoveClouds       (revision);
  RainProcess      (revision);
}
//——————————————————————————————————————————————————————————————————————————————

Подробно разберем следующий метод "MoveClouds" класса "C_AO_ACMO":

1. Первый блок (если "rev" равно "false"), метод создает облака со случайными центрами. Для каждого облака и каждой координаты:

Генерируется случайное значение центра облака в заданных диапазонах (функция "RNDfromCI").
Центр корректируется с помощью "SeInDiSp" для нормализации значений.
Определяется индекс региона, в котором находится облако, с помощью "GetRegionIndex".
Устанавливаются значения энтропии и начальной энтропии для облака.
Устанавливается начальное значение гиперэнтропии "hyperEntropy".

Метод завершает выполнение.

2. Второй блок (если "rev" равно "true"):

Если "rev" равно "true", метод начинает искать регионы с наименьшим давлением.
Создаются массивы для хранения индексов регионов с наименьшей влажностью "lHind" и для нормализации давления "normP".

3. Цикл для поиска региона с наименьшим давлением:

Для каждой координаты "c" определяется минимальное и максимальное давление среди всех регионов.
Индекс региона с наименьшим давлением сохраняется в массиве "lHind".
Нормализованное давление для каждой координаты сохраняется в "normP".

5. Перемещение облаков для каждого из них и каждой координаты:

Если облако уже находится в регионе с наименьшим давлением, пропускается итерация.
Выбирается случайный целевой регион с меньшим давлением.
Вычисляется разница давления между текущим и целевым регионом.
Нормализуется значение давления и вычисляется скорость перемещения облака "VC".
Центр облака обновляется с учетом скорости перемещения.
Индекс региона обновляется.
Энтропия облака обновляется с учетом изменения давления.
Уменьшается количество влаги в облаке и обновляется гиперэнтропия, ограничивая ее значение максимальным значением 8.

Метод "MoveClouds" отвечает за перемещение облаков в регионы с меньшим давлением, обновляя их параметры, такие как энтропия и гиперэнтропия. Метод реализует динамическую модель, отражая изменения в атмосфере.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ACMO::MoveClouds (bool &rev)
{
  //----------------------------------------------------------------------------
  if (!rev)
  {
    //creating clouds with random centers---------------------------------------
    for (int i = 0; i < cloudsNumber; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        clouds [i].center [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]);
        clouds [i].center [c] = u.SeInDiSp  (clouds [i].center [c], rangeMin [c], rangeMax [c], rangeStep [c]);

        clouds [i].regionIndex [c] = GetRegionIndex (clouds [i].center [c], c);

        clouds [i].entropy      [c] = entropy [c] * EnM0;
        clouds [i].entropyStart [c] = clouds [i].entropy [c];
      }

      clouds [i].hyperEntropy = HeM0;
    }

    return;
  }

  //search for the region with the lowest pressure------------------------------
  int targetRegion = 0;

  int lHind []; //lowest humidity index
  ArrayResize     (lHind, coords);
  ArrayInitialize (lHind, 0);

  double normP [];
  ArrayResize (normP, coords);
  double minP;
  double maxP;

  for (int c = 0; c < coords; c++)
  {
    minP =  DBL_MAX;
    maxP = -DBL_MAX;

    for (int r = 0; r < regionsNumber; r++)
    {
      if (areas [c].regions [r].pressure < areas [c].regions [lHind [c]].pressure)
      {
        lHind [c] = r;
      }

      if (areas [c].regions [r].pressure < minP) minP = areas [c].regions [r].pressure;
      if (areas [c].regions [r].pressure > maxP) maxP = areas [c].regions [r].pressure;
    }

    normP [c] = maxP - minP;
  }

  //moving the cloud to a region with less pressure-----------------------------
  int    clRegIND = 0;
  double deltaP   = 0.0;
  double α        = 0.0; // Entropy factor
  double β        = 0.0; // Atmospheric pressure factor
  double VC       = 0.0; // Cloud velocity
  double d        = 0.0; // Cloud direction

  for (int i = 0; i < cloudsNumber; i++)
  {
    for (int c = 0; c < coords; c++)
    {
      //find a region with lower pressure---------------------------------------
      if (clouds [i].regionIndex [c] == lHind [c]) continue;

      clRegIND = clouds [i].regionIndex [c];

      do targetRegion = u.RNDminusOne (regionsNumber);
      while (areas [c].regions [clRegIND].pressure < areas [c].regions [targetRegion].pressure);

      //------------------------------------------------------------------------
      deltaP = areas [c].regions [clRegIND].pressure - areas [c].regions [targetRegion].pressure;

      β = deltaP / normP [c];
      d = areas [c].regions [targetRegion].x - areas [c].regions [clRegIND].centre;

      VC = β * d;

      clouds [i].center      [c] += VC;
      clouds [i].center      [c] = u.SeInDiSp (clouds [i].center [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      clouds [i].regionIndex [c] = GetRegionIndex (clouds [i].center [c], c);

      α = β;
      clouds [i].entropy [c] *=(1 + α);
    }

    clouds [i].droplets     *=(1 - γ);
    clouds [i].hyperEntropy *=(1 + α);
    if (clouds [i].hyperEntropy > 8) clouds [i].hyperEntropy = 8;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Далее разберем метод "GetRegionIndex" класса "C_AO_ACMO". Описание метода:

1. Вычисление позиции региона. Происходит вычисление индекса региона "regPos", в котором находится заданная точка "point" и с помощью функции "floor" округляется вниз до ближайшего целого числа.
2. Проверка границ. Этот блок проверяет, не выходит ли вычисленный индекс "regPos" за пределы допустимых значений (то есть ему нельзя превышать допустимое количество регионов).
3. Метод возвращает индекс региона, в котором находится точка.

Метод "GetRegionIndex" предназначен для определения индекса региона, в котором располагается заданная точка в пределах определенного диапазона. Он учитывает количество регионов и корректно обрабатывает случаи, когда точка находится на границе диапазона.

//——————————————————————————————————————————————————————————————————————————————
int C_AO_ACMO::GetRegionIndex (double point, int ind)
{
  int regPos = (int)floor ((point - rangeMin [ind]) / ((rangeMax [ind] - rangeMin [ind]) / regionsNumber));

  if (regPos >= regionsNumber) regPos = regionsNumber - 1;

  return regPos;
}
//——————————————————————————————————————————————————————————————————————————————

Опишем следующий метод "RainProcess" класса "C_AO_ACMO":

2. Инициализация массивов:

Создаются два массива: "cloud" для хранения значений облаков и "drops" для хранения количества капель дождя для каждого облака.
Оба массива изменяются по размеру в зависимости от количества облаков "cloudsNumber".

3. Инициализация массива "cloud":

Если "rev" равно "false", все элементы массива "cloud" инициализируются значением "1.0".
Если иначе, массив "cloud" инициализируется значением "0.0" и дальше происходит вычисление влажности для каждого облака.

4. Вычисление влажности:

Для каждого облака и каждой координаты происходит вычисление влажности в зависимости от регионов.
Если влажность не равна "-DBL_MAX", она добавляется к соответствующему элементу массива "cloud". В противном случае добавляется минимальное значение капли "minGp".

5. Распределение капель:

Вызов метода "DropletsDistribution" для распределения капель на основе значений в массиве "cloud".

6. Основной цикл обработки капель, для каждого облака и каждой капли:

Вычисляются значения "dist", "centre", "xMin", "xMax".
Генерируется значение "x" с использованием нормального (гауссовского) распределения.
Если "x" выходит за пределы диапазона, оно корректируется с помощью метода "RNDfromCI".
Значение "x" нормализуется с помощью метода "SeInDiSp" и сохраняется в массиве "a".

После обработки всех капель для облака обновляется общее количество капель в облаке. Таким образом, метод "RainProcess" моделирует процесс выпадения дождя из облаков, учитывая влажность и распределение капель. Он инициализирует массивы, вычисляет влажность для каждого облака, распределяет капли дождя и генерирует значения для каждой капли с учетом нормального распределения.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ACMO::RainProcess (bool &rev)
{
  //to shed drops from every cloud----------------------------------------------
  double cloud [];
  int    drops [];
  ArrayResize (cloud, cloudsNumber);
  ArrayResize (drops, cloudsNumber);

  if (!rev)
  {
    ArrayInitialize (cloud, 1.0);
  }
  else
  {
    ArrayInitialize (cloud, 0.0);

    double humidity;

    for (int i = 0; i < cloudsNumber; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        for (int r = 0; r < regionsNumber; r++)
        {
          humidity = areas [c].regions [clouds [i].regionIndex [r]].humidity;
          if (humidity != -DBL_MAX) cloud [i] += humidity;
          else                      cloud [i] += minGp;
        }
      }
    }
  }

  DropletsDistribution (cloud, drops);

  double dist   = 0.0;
  double centre = 0.0;
  double xMin   = 0.0;
  double xMax   = 0.0;
  double x      = 0.0;
  int    dCNT   = 0;

  for (int i = 0; i < cloudsNumber; i++)
  {
    for (int dr = 0; dr < drops [i]; dr++)
    {
      for (int c = 0; c < coords; c++)
      {
        dist   = clouds [i].entropy [c];
        centre = clouds [i].center  [c];
        xMin   = centre - dist;
        xMax   = centre + dist;

        x = u.GaussDistribution (centre, xMin, xMax, clouds [i].hyperEntropy);

        if (x < rangeMin [c]) x = u.RNDfromCI (rangeMin [c], centre);
        if (x > rangeMax [c]) x = u.RNDfromCI (centre, rangeMax [c]);

        x = u.SeInDiSp (x, rangeMin [c], rangeMax [c], rangeStep [c]);

        a [dCNT].c [c] = x;
      }

      dCNT++;
    }

    clouds [i].droplets += drops [i];
  }
}
//——————————————————————————————————————————————————————————————————————————————

Следующий метод "DropletsDistribution" класса "C_AO_ACMO" предназначен для распределения капель дождя между облаками на основе их влажности. Давайте разберем его по шагам.

2. Инициализация переменных:

minHumidity- инициализируется максимальным значением, чтобы можно было найти минимальную влажность.
indMinHumidity- хранит индекс облака с минимальной влажностью.
totalHumidity - используется для хранения суммы влажности всех облаков.

3. Суммирование влажности: в этом цикле происходит суммирование влажности всех облаков и определение облака с минимальной влажностью.

4. Пропорциональное распределение капель: для каждого облака рассчитывается количество капель, пропорциональное его влажности по отношению к общей влажности. Это значение сохраняется в массив "droplets".

5. Распределение оставшихся капель:

Сначала вычисляется общее количество распределенных капель "totalDrops".
Затем вычисляется количество оставшихся капель "remainingDrops".
Если есть оставшиеся капли, они добавляются к облаку с минимальной влажностью.

Метод "DropletsDistribution" эффективно распределяет капли дождя между облаками на основе их влажности. Он сначала пропорционально распределяет капли, а затем корректирует распределение, добавляя оставшиеся капли к облаку с наименьшей влажностью. Это позволяет обеспечить более реалистичное моделирование процесса выпадения дождя, при этом соблюдать постоянное количество капель, что соответствует размеру популяции во внешних параметрах алгоритма.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ACMO::DropletsDistribution (double &cloud [], int &droplets [])
{
  double minHumidity    = DBL_MAX;
  int    indMinHumidity = -1;
  double totalHumidity  = 0; //total amount of humidity in all clouds

  for (int i = 0; i < ArraySize (cloud); i++)
  {
    totalHumidity += cloud [i];

    if (cloud [i] < minHumidity)
    {
      minHumidity = cloud [i];
      indMinHumidity = i;
    }
  }

  // Filling the droplets array in proportion to the value in clouds
  for (int i = 0; i < ArraySize (clouds); i++)
  {
    droplets [i] = int((cloud [i] / totalHumidity)*popSize); //proportional distribution of droplets
  }

  // Distribute the remaining drops, if any
  int totalDrops = 0;

  for (int i = 0; i < ArraySize (droplets); i++)
  {
    totalDrops += droplets [i];
  }

  // If not all drops are distributed, add the remaining drops to the element with the lowest humidity
  int remainingDrops = popSize - totalDrops;

  if (remainingDrops > 0)
  {
    droplets [indMinHumidity] += remainingDrops; //add the remaining drops to the lightest cloud
  }
}
//——————————————————————————————————————————————————————————————————————————————

Метод "Revision" класса "C_AO_ACMO" выполняет обновление состояния системы, подробнее разберем метод:

1. Цикл по элементам массива "a" (популяция агентов оптимизации). В этом цикле происходит итерация по всем элементам массива "a" размером "popSize":

Если значение приспособленности "f" текущего элемента больше, чем текущее максимальное значение приспособленности "fB", то обновляется "fB", и индекс "ind" устанавливается в текущий индекс.
Также происходит поиск минимального значения приспособленности "f" среди всех элементов массива, и если текущее значение меньше, чем "minGp", то "minGp" обновляется.

2. Копирование данных: если был найден элемент с максимальным значением приспособленности "f" (то есть "ind" не равен -1), то происходит копирование данных из массива "c" элемента "a [ind]" в массив "cB".

3. Обновление свойств региона: вызывается метод "UpdateRegionProperties", который обновляет параметры влажности и давления в различных регионах.

4. Генерация облаков: вызывается метод "GenerateClouds", который отвечает за исчезновение старых облаков и создание новых.

5. Обновление состояния:

Устанавливается флаг "revision" в "true", что указывает на то, что первоначальное состояние системы пройдено.
Увеличивается счетчик "epochNow" для отслеживания количества эпох.

Метод "Revision" отвечает за обновление состояния системы, связанной с облаками. Он находит максимальное значение приспособленности "f", обновляет соответствующие параметры, инициализирует новые облака и обновляет свойства регионов. Этот метод является ключевым для поддержания актуальности данных в модели, что позволяет системе адаптироваться к изменениям.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ACMO::Revision ()
{
  //----------------------------------------------------------------------------
  int ind = -1;

  for (int i = 0; i < popSize; i++)
  {
    if (a [i].f > fB)
    {
      fB = a [i].f;
      ind = i;
    }

    if (a [i].f < minGp) minGp = a [i].f;
  }

  if (ind != -1) ArrayCopy (cB, a [ind].c, 0, 0, WHOLE_ARRAY);

  //----------------------------------------------------------------------------
  UpdateRegionProperties (); //updating humidity and pressure in the regions
  GenerateClouds         (); //disappearance of clouds and the creation of new ones

  revision = true;
  epochNow++;
}
//——————————————————————————————————————————————————————————————————————————————

Метод "GenerateClouds" класса "C_AO_ACMO" отвечает за создание облаков и управление их состоянием в зависимости от различных факторов, таких как влажность и энтропия. Описание метода:

1. Расчет порога влажности: вызывается функция "CalculateHumidityThreshold", которая возвращает значение порога влажности, необходимое для формирования облаков.

2. Структура для хранения индексов регионов:

Определяется структура "S_Areas", которая содержит массив индексов регионов, способных к образованию облаков.
Массив "ar" инициализируется с размером, равным количеству координат "coords".

3. Сбор информации о регионах: в этом двойном цикле происходит проверка каждого региона на соответствие порогу влажности. Если влажность региона больше порога, индекс этого региона добавляется в массив "regsIND" соответствующей структуры "S_Areas".

4. Проверка условий распада облаков:

Для каждого облака проверяется, не превышает ли его энтропия определенный предел (в 5 раз больше начальной энтропии). Если это так, облако считается распавшимся.
Затем проверяется, если количество влаги в облаке меньше минимального значения "dMin", что также может привести к распаду облака.

5. Создание нового облака в самых влажных регионах:

Если облако распалось, происходит создание нового облака в одном из самых влажных регионов. Для каждой координаты случайным образом выбирается индекс региона, и облако получает новые координаты центра и индекс региона.
Затем вызывается функция "CalculateNewEntropy", которая пересчитывает энтропию в зависимости от текущей эпохи для нового облака.

Метод "GenerateClouds" управляет процессом создания и распада облаков на основе влажности и энтропии. Он собирает информацию о регионах, способных к образованию облаков, проверяет существующие облака на предмет распада и создает новые облака в подходящих регионах. Этот метод является ключевым для динамического управления состоянием облаков в модели.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ACMO::GenerateClouds ()
{
  //Collecting statistics of regions capable of creating clouds-----------------
  double Ht = CalculateHumidityThreshold ();

  struct S_Areas
  {
      int regsIND []; //index of the potential region
  };

  S_Areas ar [];
  ArrayResize (ar, coords);

  int sizePr = 0;

  for (int i = 0; i < coords; i++)
  {
    for (int r = 0; r < regionsNumber; r++)
    {
      if (areas [i].regions [r].humidity > Ht)
      {
        sizePr = ArraySize (ar [i].regsIND);
        sizePr++;
        ArrayResize (ar [i].regsIND, sizePr, coords);
        ar [i].regsIND [sizePr - 1] = r;
      }
    }
  }

  //Check the conditions for cloud decay----------------------------------------
  bool   cloudDecay = false;

  for (int i = 0; i < cloudsNumber; i++)
  {
    cloudDecay = false;

    //checking the cloud for too much entropy-----------------------------------
    for (int c = 0; c < coords; c++)
    {
      if (clouds [i].entropy [c] > 5.0 * clouds [i].entropyStart [c])
      {
        //Print ("Распад облака №", i, " - порвалось на эпохе ", epochNow);
        cloudDecay = true;
        break;
      }
    }

    //checking the cloud for decay----------------------------------------------
    if (!cloudDecay)
    {
      if (clouds [i].droplets < dMin)
      {
        //Print ("Распад облака №", i, " - высохло на эпохе ", epochNow);
        cloudDecay = true;
      }
    }

    //if the cloud has decayed--------------------------------------------------
    int regIND = 0;

    if (cloudDecay)
    {
      //creating a cloud in a very humid region---------------------------------
      for (int c = 0; c < coords; c++)
      {
        regIND = u.RNDminusOne (ArraySize (ar [c].regsIND));
        regIND = ar [c].regsIND [regIND];

        clouds [i].center      [c] = areas [c].regions [regIND].x;
        clouds [i].regionIndex [c] = regIND;
      }

      CalculateNewEntropy (clouds [i], epochNow);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Метод "CalculateHumidityThreshold" класса "C_AO_ACMO" отвечает за вычисление порога влажности, необходимого для формирования облаков, далее подробно по шагам:

1. Двойной цикл для поиска минимальной влажности. Внешний цикл проходит по всем координатам "coords", а внутренний цикл — по всем регионам "regionsNumber" в каждой координате. Если влажность региона не равна "-DBL_MAX", происходит проверка: если текущая влажность меньше текущего "H_min", то обновляется "H_min".

2. Метод возвращает значение, которое представляет собой "H_min", увеличенное на произведение "λ" и разности между "H_max" и "H_min", что представляет собой порог влажности, необходимый для формирования облаков.

Метод "CalculateHumidityThreshold" вычисляет порог влажности, основываясь на минимальной влажности среди всех регионов, и корректирует его с учетом максимальной влажности и коэффициента "λ". Это позволяет определять, при каких условиях возможно образование облаков, исходя из состояния окружающей среды.

//——————————————————————————————————————————————————————————————————————————————
double C_AO_ACMO::CalculateHumidityThreshold ()
{
  double H_max = fB;
  double H_min = DBL_MAX;

  for (int c = 0; c < coords; c++)
  {
    for (int r = 0; r < regionsNumber; r++)
    {
      if (areas [c].regions [r].humidity != -DBL_MAX)
      {
        if (areas [c].regions [r].humidity < H_min)
        {
          H_min = areas [c].regions [r].humidity;
        }
      }
    }
  }

  return H_min + λ * (H_max - H_min);
}
//——————————————————————————————————————————————————————————————————————————————

Метод "CalculateNewEntropy" класса "C_AO_ACMO" отвечает за вычисление новой энтропии и гиперэнтропии для облаков, представленных структурой "S_ACMO_Cloud". Разберем его:

1. Вычисление энтропии:

Цикл проходит по всем координатам "coords".
Для каждой координаты вычисляется новое значение энтропии "cl.entropy [c]", используя формулу: En = (entropy [c] * EnM0) / (1 + e ^ (-(8 - 16 * (t / epochs)))).
cl.entropyStart [c] и cl.entropy [c] инициализируются значением "entropy [c]", что служит для сохранения начального значения энтропии.

2. Вычисление гиперэнтропии: He = 1 / (1 + e ^ (8 - 16 * (t / epochs))).

3. Гиперэнтропия масштабируется с помощью метода "Scale" объекта "u", что позволяет масштабировать значение гиперэнтропии в заданный диапазон (от 0 до 8) с использованием параметров "HeM0" и 8.0.

Метод "CalculateNewEntropy" обновляет значения энтропии и гиперэнтропии для облаков, основываясь на текущем времени "t" и заданных параметрах.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ACMO::CalculateNewEntropy (S_ACMO_Cloud &cl, int t)
{
  //----------------------------------------------------------------------------
  //En: 1/(1+2.72^(-(8-16*(t/maxT))))
  for (int c = 0; c < coords; c++)
  {
    cl.entropy      [c] = entropy [c] * EnM0 / (1.0 + pow (M_E, (-(8.0 - 16.0 * (t / epochs)))));
    cl.entropyStart [c] = cl.entropy [c] = entropy [c];
  }

  //----------------------------------------------------------------------------
  //He: 1/(1+2.72^((8-16*(t/maxT))))
  cl.hyperEntropy = 1.0 / (1.0 + pow (M_E, ((8.0 - 16.0 * (t / epochs)))));

  cl.hyperEntropy = u.Scale (cl.hyperEntropy, 0.0, 8.0, HeM0, 8.0);
}
//——————————————————————————————————————————————————————————————————————————————

En and He 2

Рисунок 1. Варианты формул для вычисления коэффициента ζ в зависимости от текущей эпохи. Выбрать формулу и попробовать работу алгоритма можно с каждой из них (в коде строки закомментированы).

Результаты тестов

Переходим к тестированию алгоритма. Метеорологическая модель формирования облаков по замыслу авторов работает следующим образом:

//original version
ACMO|Atmospheric Cloud Model Optimization|50.0|5.0|10.0|0.2|5.0|5.0|0.9|0.2|
=============================
5 Hilly's; Func runs: 10000; result: 0.6017884495404766
25 Hilly's; Func runs: 10000; result: 0.3426222382089618
500 Hilly's; Func runs: 10000; result: 0.2526410178225118
=============================
5 Forest's; Func runs: 10000; result: 0.4780554376190664
25 Forest's; Func runs: 10000; result: 0.261057831391174
500 Forest's; Func runs: 10000; result: 0.17318135866144563
=============================
5 Megacity's; Func runs: 10000; result: 0.3507692307692307
25 Megacity's; Func runs: 10000; result: 0.16153846153846158
500 Megacity's; Func runs: 10000; result: 0.09632307692307775
=============================
All score: 2.71798 (30.20%)

К сожалению, результаты намного ниже ожидаемых, думаю, что несмотря на красивую модель принципа формирования облаков с большим количеством различных формул и логических действий, направленных на избежание застревания в экстремумах, сходимость алгоритм показывает невысокую. В алгоритме отсутствует прямое взаимодействие и обмен информацией между агентами лучшими решениями, наличие которого обычно приводит к улучшению поисковых качеств любого алгоритма. В результате я решил добавить обмен информацией посредством вероятностной передачи сведений от лучших капель худшим. Теперь посмотрим, что из этого получилось:

ACMOm|Atmospheric Cloud Model Optimization|50.0|4.0|10.0|0.2|0.2|2.0|0.9|0.9|
=============================
5 Hilly's; Func runs: 10000; result: 0.9032099148349984
25 Hilly's; Func runs: 10000; result: 0.48545807643133143
500 Hilly's; Func runs: 10000; result: 0.30403284557071203
=============================
5 Forest's; Func runs: 10000; result: 0.8026793420899985
25 Forest's; Func runs: 10000; result: 0.3785708322859447
500 Forest's; Func runs: 10000; result: 0.1917777390119122
=============================
5 Megacity's; Func runs: 10000; result: 0.6230769230769231
25 Megacity's; Func runs: 10000; result: 0.244
500 Megacity's; Func runs: 10000; result: 0.10795384615384714
=============================
All score: 4.04076 (44.90%)

Результаты значительно улучшились. Следовательно, идея оказалась успешной. Идея заключается в передаче информации о лучшем решении с некоторой вероятностью каплям облаков от других капель, если они имеют более высокую влажность (в контексте алгоритма — это приспособленность).

В конце для каждого облака обновляется общее количество капель (для облака — это показатель влажности), сброшенных из него, добавляя соответствующее значение из массива "drops". Метод "RainProcess" реализует механизм, который моделирует процесс дождя, учитывая влажность, распределение капель и взаимодействие с популяцией. Зеленым цветом выделено место внесения изменений в код.

Для каждого сгенерированного значения "x" происходит выбор случайного индекса "p" из популяции. В зависимости от вероятности (95%), происходит обновление значений в массиве "a", который представляет собой популяцию или набор решений. В конце для каждого облака обновляется общее количество капель, сброшенных из него, добавляя соответствующее значение из массива "drops".

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ACMO::RainProcess (bool &rev)
{
  //to shed drops from every cloud----------------------------------------------
  double cloud [];
  int    drops [];
  ArrayResize (cloud, cloudsNumber);
  ArrayResize (drops, cloudsNumber);

  if (!rev)
  {
    ArrayInitialize (cloud, 1.0);
  }
  else
  {
    ArrayInitialize (cloud, 0.0);

    double humidity;

    for (int i = 0; i < cloudsNumber; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        humidity = areas [c].regions [clouds [i].regionIndex [c]].humidity;
       
        if (humidity != -DBL_MAX) cloud [i] += humidity;

        else                      cloud [i] += minGp;
      }
    }
  }

  DropletsDistribution (cloud, drops);
  //ArrayPrint (drops);

  double dist   = 0.0;
  double centre = 0.0;
  double xMin   = 0.0;
  double xMax   = 0.0;
  double x      = 0.0;

  int    dCNT   = 0;


  for (int i = 0; i < cloudsNumber; i++)
  {
    for (int dr = 0; dr < drops [i]; dr++)
    {
      for (int c = 0; c < coords; c++)
      {
        dist   = clouds [i].entropy [c];
        centre = clouds [i].center  [c];
        xMin   = centre - dist;
        xMax   = centre + dist;

        x = u.GaussDistribution (centre, xMin, xMax, clouds [i].hyperEntropy);

        if (x < rangeMin [c]) x = u.RNDfromCI (rangeMin [c], centre);
        
        if (x > rangeMax [c]) x = u.RNDfromCI (centre, rangeMax [c]);

        x = u.SeInDiSp (x, rangeMin [c], rangeMax [c], rangeStep [c]);

        int p = u.RNDminusOne (popSize);

        if (a [p].f > a [dCNT].f)
        {
          if (u.RNDprobab () < 0.95) a [dCNT].c [c] = a [p].c [c];
        }

        else
        {
          a [dCNT].c [c] = x;
        }
      }
      dCNT++;
    }

    clouds [i].droplets += drops [i];
  }
}
//——————————————————————————————————————————————————————————————————————————————

На визуализации работы алгоритма можно заметить следующее: хорошую сходимость алгоритма, продолжительные пологие участки на графике сходимости с малым количеством оптимизируемых параметров указывают на некоторую склонность к застреванию алгоритма в локальных экстремумах, а при увеличении количества параметров этот недостаток сходит на нет.

Облака на визуализации выглядят как плотные скопления, однако при выборе иных настроек внешних параметров (количество регионов, облаков, начальная энтропия и пороговое значение высыхания), они могут имитировать вид плывущих облаков в небе, как в живой природе.

Hilly

AСMO на тестовой функции Hilly

Forest

ACMO на тестовой функции Forest

Megacity

ACMO на тестовой функции Megacity

По результатам тестирования модифицированной версии алгоритм занимает 27 место, что является достаточно стабильным показателем. Хотел бы подчеркнуть, что в таблице теперь присутствует всегда 45 алгоритмов и собственно с каждым новым алгоритмом разница между предыдущими и последующими будет постепенно сокращаться, таким образом, можно сказать, что таблица представляет собой топ лучших из всех известных алгоритмов.

№	AO	Description	Hilly			Hilly final	Forest			Forest final	Megacity (discrete)			Megacity final	Final result	% of MAX
№	AO	Description	10 p (5 F)	50 p (25 F)	1000 p (500 F)	Hilly final	10 p (5 F)	50 p (25 F)	1000 p (500 F)	Forest final	10 p (5 F)	50 p (25 F)	1000 p (500 F)	Megacity final	Final result	% of MAX
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	AMOm	animal migration ptimization M	0,90358	0,84317	0,46284	2,20959	0,99001	0,92436	0,46598	2,38034	0,56769	0,59132	0,23773	1,39675	5,987	66,52
4	(P+O)ES	(P+O) evolution strategies	0,92256	0,88101	0,40021	2,20379	0,97750	0,87490	0,31945	2,17185	0,67385	0,62985	0,18634	1,49003	5,866	65,17
5	CTA	comet tail algorithm	0,95346	0,86319	0,27770	2,09435	0,99794	0,85740	0,33949	2,19484	0,88769	0,56431	0,10512	1,55712	5,846	64,96
6	SDSm	stochastic diffusion search M	0,93066	0,85445	0,39476	2,17988	0,99983	0,89244	0,19619	2,08846	0,72333	0,61100	0,10670	1,44103	5,709	63,44
7	AAm	archery algorithm M	0,91744	0,70876	0,42160	2,04780	0,92527	0,75802	0,35328	2,03657	0,67385	0,55200	0,23738	1,46323	5,548	61,64
8	ESG	evolution of social groups	0,99906	0,79654	0,35056	2,14616	1,00000	0,82863	0,13102	1,95965	0,82333	0,55300	0,04725	1,42358	5,529	61,44
9	SIA	simulated isotropic annealing	0,95784	0,84264	0,41465	2,21513	0,98239	0,79586	0,20507	1,98332	0,68667	0,49300	0,09053	1,27020	5,469	60,76
10	ACS	artificial cooperative search	0,75547	0,74744	0,30407	1,80698	1,00000	0,88861	0,22413	2,11274	0,69077	0,48185	0,13322	1,30583	5,226	58,06
11	ASO	anarchy society optimization	0,84872	0,74646	0,31465	1,90983	0,96148	0,79150	0,23803	1,99101	0,57077	0,54062	0,16614	1,27752	5,178	57,54
12	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
13	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
14	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
15	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
16	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
17	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
18	BCOm	bacterial chemotaxis optimization M	0,75953	0,62268	0,31483	1,69704	0,89378	0,61339	0,22542	1,73259	0,65385	0,42092	0,14435	1,21912	4,649	51,65
19	(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
20	TSm	tabu search M	0,87795	0,61431	0,29104	1,78330	0,92885	0,51844	0,19054	1,63783	0,61077	0,38215	0,12157	1,11449	4,536	50,40
21	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
22	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
23	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
24	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
25	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
26	ABHA	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
27	ACMO	atmospheric cloud model optimization	0,90321	0,48546	0,30403	1,69270	0,80268	0,37857	0,19178	1,37303	0,62308	0,24400	0,10795	0,97503	4,041	44,90
28	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
29	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
30	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
31	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
32	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
33	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
34	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
35	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
36	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
37	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
38	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
39	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
40	AAA	algae adaptive algorithm	0,50007	0,32040	0,25525	1,07572	0,37021	0,22284	0,16785	0,76089	0,27846	0,14800	0,09755	0,52402	2,361	26,23
41	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
42	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
43	PSO	particle swarm optimisation	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
44	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
45	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

Выводы

Представлены две версии алгоритма: оригинальная и модифицированная. Последняя включает небольшие изменения, но значительно повышает результативность, благодаря обмену информацией в популяции. Это демонстрирует, что даже незначительные корректировки в логике алгоритма могут привести к заметному увеличению эффективности в различных задачах.

Идея алгоритма мне очень понравилась, так как она направлена на избежание застревания в экстремумах. Алгоритм использует сложную многоступенчатую логику перемещения облаков из зон высокого давления в зоны низкого и выпадения осадков. Однако этого не оказалось достаточным для достижения высокой сходимости. В результате я предпринял попытку модификации, введя обмен информацией в популяции, что помогло улучшить сходимость — это один из ключевых аспектов любого алгоритма оптимизации.

Особенность алгоритма заключается в том, что ни одно облако не остается на месте слишком долго. Непрерывно повышающееся давление в регионе неизбежно выталкивает облако в новый, неисследованный район. Этот механизм был задуман авторами как средство противодействия застреванию в локальных экстремумах. Однако попытка повысить сходимость алгоритма увеличила вероятность застревания, что, к сожалению, частично нивелировало ключевую особенность, вдохновившую меня на возможность применения данного подхода в других алгоритмах оптимизации. Проектирование любого алгоритма оптимизации всегда связано с поиском компромисса между устойчивостью к застреванию и нахождением точного решения. При желании, вероятность обмена информацией можно снизить в коде; в данный момент она составляет 95%, что позволит повысить устойчивость.

Алгоритм представляет собой замечательную базу и набор интересных приемов (правила формирования влажности в регионах и распределения давления между ними, а также дополнительно могут быть применены физические законы ускорения и инерции, зависящие от массы облаков и многие другие идеи) и является находкой для исследователей.

Tab

Рисунок 2. Гистограмма результатов тестирования алгоритмов (по шкале от 0 до 100, чем больше, тем лучше, где 100 - максимально возможный теоретический результат, в архиве скрипт для расчета рейтинговой таблицы)

chart

Рисунок 3. Цветовая градация алгоритмов по соответствующим тестам. Белым цветом подсвечены результаты больше или равные 0.99

Плюсы и минусы алгоритма ACMO:

Плюсы:

Встроенные механизмы против застревания.
Неплохая сходимость.
Неплохая масштабируемость.

Минусы:

Огромное количество внешних параметров.
Сложная реализация.
Сложно подобрать параметрами баланс между застреванием и сходимостью.

К статье прикреплён архив с актуальными версиями кодов алгоритмов. Автор статьи не несёт ответственности за абсолютную точность в описании канонических алгоритмов, во многие из них были внесены изменения для улучшения поисковых возможностей. Выводы и суждения, представленные в статьях, основываются на результатах проведённых экспериментов.

github: https://github.com/JQSakaJoo/Population-optimization-algorithms-MQL5

Прикрепленные файлы |

Загрузить ZIP

ACMO.ZIP (38.88 KB)

Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.

Другие статьи автора

Перейти к обсуждению на форуме трейдеров

Возможности Мастера MQL5, которые вам нужно знать (Часть 19): Байесовский вывод

Байесовский вывод — это применение теоремы Байеса для обновления вероятностной гипотезы по мере поступления новой информации. Это намекает на необходимость адаптации в анализе временных рядов, и поэтому мы рассмотрим, как мы могли бы использовать его при создании пользовательских классов не только применительно к сигналам, но и для управления капиталом и трейлинг-стопами.

Нейросети в трейдинге: Безмасочный подход к прогнозированию ценового движения

В данной статье предлагаем познакомиться с методом Mask-Attention-Free Transformer (MAFT) и его применение в области трейдинга. В отличие от традиционных Transformer, требующих маскирования данных при обработке последовательностей, MAFT оптимизирует процесс внимания, устраняя необходимость в маскировании, что значительно повышает вычислительную эффективность.

DoEasy. Сервисные функции (Часть 3): Паттерн "Внешний бар"

В статье разработаем паттерн Price Action "Внешний Бар" в библиотеке DoEasy и оптимизируем методы доступа к управлению ценовыми паттернами. Кроме того, проведём работу по исправлению ошибок и недоработок, выявленных при тестировании библиотеки.

Оптимизация атмосферными облаками — Atmosphere Clouds Model Optimization (ACMO): Теория

Статья посвящена метаэвристическому алгоритму Atmosphere Clouds Model Optimization (ACMO), который моделирует поведение облаков для решения задач оптимизации. Алгоритм использует принципы генерации, движения и распространения облаков, адаптируясь к "погодным условиям" в пространстве решений. Статья раскрывает, как метеорологическая симуляция алгоритма находит оптимальные решения в сложном пространстве возможностей и подробно описывает этапы работы ACMO, включая подготовку "неба", рождение облаков, их перемещение и концентрацию дождя.