Алгоритм искусственного пчелиного улья — Artificial Bee Hive Algorithm (ABHA): Тестирование и результаты

Содержание

1. Введение
2. Продолжение реализации алгоритма
3. Результаты тестов

1. Введение

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

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

Напомним основные моменты алгоритма ABHA, основанного на модели индивидуального состояния и поведения пчел:

• Каждая пчела представлена как индивидуальный агент, поведение которого регулируется состояниями (новичок, опытный, исследователь, эксплуатирующий).
• В каждый момент времени поведение одной пчелы определяется доступной ей внутренней и внешней информацией, а также ее мотивационным состоянием, в соответствии с набором конкретных правил.
• Набор правил одинаков для каждой пчелы, но поскольку воспринимаемая среда различается для пчел с разным пространственным положением, их поведение также различается.
• Пчелы могут проявлять различное поведение в зависимости от их опыта сбора пищи и/или их мотивационного состояния.

Таким образом, модель ABHA представляет поведение пчел как регулируемое набором правил, которое адаптируется к индивидуальным особенностям и окружающей среде.

2. Продолжение реализации алгоритма

Приступим к продолжению написания методов алгоритма по нашему псевдокоду, описанному в предыдущей статье. Итак, начнем.

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

• Параметры - метод принимает ссылку на объект "agent" типа "S_ABHA_Agent", который представляет собой "новичка" в алгоритме.
• Возвращаемое значение - метод не возвращает ничего (void).

Логика метода:

1. Объявляется переменная "val", для хранения текущей координаты агента.

2. Цикл "for" проходит по всем координатам агента, где "coords" - это общее количество координат (или измерений) в пространстве поиска.

3. Внутри цикла значение текущей координаты агента сохраняется в переменной "val".

4. В зависимости от вероятности, определяется, какое действие выполнить:

• Случайный поиск - если сгенерированное случайное число (через u.RNDprobab ()) меньше значения "randomSearchProbability", выполняется случайный поиск и координата "c" обновляется с помощью метода "ActionRandomSearch (c)", который генерирует новую позицию в этом измерении.
• Следование за танцем - в противном случае агент будет следовать за "танцем" других агентов. В этом случае координата "c" обновляется с помощью метода "ActionFollowingDance (c, val)", который использует значение "val" для определения новой позиции на основе информации о других агентах.

Метод "StageActivityNovice" управляет поведением новичков в алгоритме ABHA и в итоге выполняет следующие ключевые действия:

1. Проходит по каждой координате агента.

2. В зависимости от случайной вероятности, решает, будет ли агент выполнять случайный поиск или следовать за "танцем" других агентов.

3. Обновляет позицию агента в каждой координате в соответствии с выбранным действием.

Этот метод позволяет новичкам адаптироваться к окружающей среде, используя как случайные стратегии, так и стратегии, основанные на взаимодействии с другими агентами.

//——————————————————————————————————————————————————————————————————————————————
//Действия 1 или 2
void C_AO_ABHA::StageActivityNovice (S_ABHA_Agent &agent)
{
  double val;

  for (int c = 0; c < coords; c++)
  {
    val = agent.position [c];

    if (u.RNDprobab () < randomSearchProbability) agent.position [c] = ActionRandomSearch   (c);
    else                                          agent.position [c] = ActionFollowingDance (c, val);
  }
}
//——————————————————————————————————————————————————————————————————————————————

Метод "StageActivityExperienced" в классе "C_AO_ABHA" отвечает за действия опытных агентов в алгоритме ABHA и управляет тем, как опытные агенты выбирают свои действия в зависимости от случайных вероятностей и их текущих стратегий.

1. Объявляется переменная "rnd", которая будет использоваться для хранения случайного числа, генерируемого для принятия решения о действиях агента.

2. Цикл "for" проходит по всем координатам агента, где "coords" - это общее количество координат (или измерений) в пространстве поиска.

3. Внутри цикла для каждой координаты генерируется случайное число "rnd" с использованием метода "RNDprobab ()", который возвращает значение от "0" до "1".

4. Если случайное число "rnd" меньше или равно "agent.p_srs" (вероятность случайного поиска), агент выполняет случайный поиск, обновляя свою позицию в координате "c" с помощью метода "ActionRandomSearch (c)".

Вероятность следования танцу:

• Если "rnd" больше "agent.p_srs" и меньше или равно "agent.p_rul" (вероятность следования за танцем), агент будет следовать за "танцем" других агентов, обновляя свою позицию с помощью метода "ActionFollowingDance (c, agent.position [c])".

Вероятность оставаться у источника:

• Если ни одно из предыдущих условий не выполнено, агент остается у источника, обновляя свою позицию с помощью метода "ActionHiveVicinity (c, agent.bestPosition [c])", где "agent.bestPosition [c]" представляет собой наилучшую известную позицию агента.

Метод "StageActivityExperienced" управляет поведением опытных агентов в алгоритме ABHA и в итоге выполняет следующее:

1. Проходит по каждой координате агента.

2. Генерирует случайное число для выбора действия.

3. В зависимости от сгенерированного числа и вероятностей, определяет, будет ли агент выполнять случайный поиск, следовать за "танцем" других агентов или оставаться у источника.

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

//——————————————————————————————————————————————————————————————————————————————
//действия 1 или 2 или 4
void C_AO_ABHA::StageActivityExperienced (S_ABHA_Agent &agent)
{
  double rnd = 0;

  for (int c = 0; c < coords; c++)
  {
    rnd = u.RNDprobab ();

    // вероятность случайного поиска
    if (rnd <= agent.p_srs)
    {
      agent.position [c] = ActionRandomSearch (c);
    }
    else
    {
      // Вероятность следования танцу
      if (agent.p_srs < rnd && rnd <= agent.p_rul)
      {
        agent.position [c] = ActionFollowingDance (c, agent.position [c]);
      }
      // Вероятность оставаться у источника
      else
      {
        agent.position [c] = ActionHiveVicinity (c, agent.bestPosition [c]);
      }
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Метод "StageActivitySearch" в классе "C_AO_ABHA" отвечает за действия агентов во время этапа поиска и управляет тем, как агенты перемещаются в пространстве поиска, обновляя свои позиции в зависимости от выбранного направления. Метод выполняет следующие действия:

1. Проходит по каждой координате агента.

2. Для каждой координаты вызывает метод "ActionMovingDirection", который определяет новое направление движения агента.

3. Обновляет позицию агента в соответствующей координате.

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

//——————————————————————————————————————————————————————————————————————————————
//Действия 3
void C_AO_ABHA::StageActivitySearch (S_ABHA_Agent &agent)
{
  for (int c = 0; c < coords; c++)
  {
    agent.position [c] = ActionMovingDirection (agent, c);
  }
}
//——————————————————————————————————————————————————————————————————————————————

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

1. Инициализирует переменную "val".

2. Проходит по каждой координате агента.

3. Для каждой координаты обновляет позицию агента, вызывая метод "ActionHiveVicinity", который определяет новое положение агента на основе его наилучшей известной позиции.

Этот метод помогает агентам в состоянии "эксплуатирующий" концентрировать всё своё внимание на детальном исследовании окрестностей известного источника пищи.

//——————————————————————————————————————————————————————————————————————————————
//Действия 4
void C_AO_ABHA::StageActivitySource (S_ABHA_Agent &agent)
{
  double val = 0;

  for (int c = 0; c < coords; c++)
  {
    agent.position [c] = ActionHiveVicinity (c, agent.bestPosition [c]);
  }
}
//——————————————————————————————————————————————————————————————————————————————

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

1. Принимает индекс координаты, для которой необходимо сгенерировать случайное значение.

2. Использует метод генерации случайных чисел для получения значения в диапазоне, определенном минимальным и максимальным значениями для данной координаты.

3. Возвращает случайно сгенерированное значение типа "double".

//——————————————————————————————————————————————————————————————————————————————
//1. Случайный поиск (случайное размещение в диапазоне координат)
double C_AO_ABHA::ActionRandomSearch (int coordInd)
{
  return u.RNDfromCI (rangeMin [coordInd], rangeMax [coordInd]);
}
//——————————————————————————————————————————————————————————————————————————————

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

1. Вычисление общей вероятности:

• Инициализируется переменная "totalProbability", которая будет хранить сумму вероятностей "p_si" всех агентов, находящихся в состоянии "опытный".
• В цикле по всем агентам проверяется их состояние, и если агент опытный, его вероятность добавляется к "totalProbability".

2. Генерация случайного значения и выбор агента:

• Генерируется случайное значение "randomValue", которое нормализуется относительно "totalProbability".
• В следующем цикле происходит накопление вероятностей "p_si" опытных агентов. Как только накопленная вероятность превышает "randomValue", индекс выбранного агента "ind" сохраняется, и цикл прерывается.
  

3. Проверка выбранного агента и вычисление нового значения:

• Если ни один агент не был выбран (индекс "ind" остался равным "-1"), вызывается метод "ActionRandomSearch" для выполнения случайного поиска.
• Если агент был выбран, вычисляется направление движения "direction" как разница между лучшей позицией выбранного агента и текущим значением "val".
• Генерируется случайный шум "noise" в диапазоне от "-1" до "1".
• Возвращается новое значение, которое представляет собой текущее значение "val", скорректированное на направление и шум.

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

———————————————————————————————————————————————————————————————————————
//2. Следование за танцем (двигаться в направлении танцора)
double C_AO_ABHA::ActionFollowingDance (int coordInd, double val)
{
  //----------------------------------------------------------------------------
  double totalProbability = 0;

  for (int i = 0; i < popSize; i++)
  {
    if (agents [i].state == S_ABHA_Agent::stateExperienced)
    {
      totalProbability += agents [i].p_si;
    }
  }

  //----------------------------------------------------------------------------
  double randomValue = u.RNDprobab () * totalProbability;
  double cumulativeProbability = 0;
  int    ind = -1;

  for (int i = 0; i < popSize; i++)
  {
    if (agents [i].state == S_ABHA_Agent::stateExperienced)
    {
      cumulativeProbability += agents [i].p_si;

      if (cumulativeProbability >= randomValue)
      {
        ind = i;
        break;
      }
    }
  }

  //----------------------------------------------------------------------------
  if (ind == -1)
  {
    return ActionRandomSearch (coordInd);
  }

  double direction = agents [ind].bestPosition [coordInd] - val;
  double noise     = u.RNDfromCI (-1.0, 1.0);

  return val + direction * noise;
}
//——————————————————————————————————————————————————————————————————————————————

Метод "ActionMovingDirection" в классе "C_AO_ABHA" отвечает за перемещение агента в заданном направлении с определенным шагом. Давайте разберем код по частям.

1. Перемещение агента:

• Обновление позиции агента по указанной координате "coordInd".
• agent.position [coordInd] - текущая позиция агента по данной координате.
• agent.stepSize - величина шага, на который агент перемещается в этом направлении.
• agent.direction [coordInd] - направление движения агента по указанной координате.
  
• Умножая "stepSize" на "direction", мы получаем величину перемещения, которая добавляется к текущей позиции агента.

2. Уменьшение величины шага:

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

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

//——————————————————————————————————————————————————————————————————————————————
//3. Перемещение в заданном направлении с шагом
double C_AO_ABHA::ActionMovingDirection (S_ABHA_Agent &agent, int coordInd)
{
  agent.position [coordInd] += agent.stepSize * agent.direction [coordInd];
  agent.stepSize *= stepSizeReductionFactor;

  return agent.position [coordInd];
}
//——————————————————————————————————————————————————————————————————————————————

Метод "ActionHiveVicinity" в классе "C_AO_ABHA" предназначен для определения поведения агента в окрестностях источника пищи. Метод "ActionHiveVicinity" отвечает за генерацию нового положения по заданной координате, причем с большей вероятностью в окрестностях текущего положения, чем вдали от него.

//——————————————————————————————————————————————————————————————————————————————
//4. Двигаться в окрестностях источника пищи
double C_AO_ABHA::ActionHiveVicinity (int coordInd, double val)
{
  return u.PowerDistribution (val, rangeMin [coordInd], rangeMax [coordInd], 12);
}
//——————————————————————————————————————————————————————————————————————————————

Давайте разберем следующий метод "ChangingStateForNovice" в классе "C_AO_ABHA", который отвечает за изменение состояния агента в зависимости от его текущей приспособленности "cost" и информации об источниках пищи.

1. Предыдущая и лучшая стоимость не используются в этом методе.

2. Проверка состояния:

• Если текущая стоимость источника пищи "agent.cost" превышает среднюю стоимость "avgCost", то состояние агента меняется на опытного "stateExperienced". Это означает, что агент получил достаточно информации о высокоприбыльных источниках пищи и готов действовать более эффективно.

3. Переход в состояние "Исследователь":

• Если текущая стоимость не превышает среднюю, агент переходит в состояние исследователя "stateSearch". Это состояние предполагает, что агент не имеет информации об источниках пищи и должен начать случайный поиск.

4. Случайное направление поиска:

• Цикл проходит по всем координатам "coords" и для каждой координаты агенту присваивается случайное направление. Метод "RNDfromCI" генерирует случайное число в указанном диапазоне и используется для определения размера перемещения и направления в пределах заданного диапазона "rangeMin" и "rangeMax".

5. Инициализация параметров поиска:

• Устанавливается размер шага "stepSize" для движения агента, а также счетчик поиска "searchCounter", который отслеживает количество итераций, сделанных агентом в поисках пищи.

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

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ABHA::ChangingStateForNovice (S_ABHA_Agent &agent)
{
  //Текущая стоимость   : Используется для перехода в состояние либо Опытный либо Исследователь.
  //Предыдущая стоимость: Не используется.
  //Лучшая стоимость    : Не используется.

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

  if (agent.cost > avgCost) agent.state = S_ABHA_Agent::stateExperienced;
  else
  {
    agent.state = S_ABHA_Agent::stateSearch;

    for (int c = 0; c < coords; c++)
    {
      agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c]));
    }

    agent.stepSize        = initialStepSize;
    agent.searchCounter   = 0;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Метод "ChangingStateForExperienced" в классе "C_AO_ABHA" предназначен для управления состоянием опытного агента пчелы в зависимости от его текущей ценности источника пищи и предыдущего значения. Подробно разберем этот метод.

1. Изменение параметра "pab":

• Если текущая стоимость меньше предыдущей: пчела снижает вероятность оставаться у источника пищи "pab". Если "pab" становится меньше "0", оно устанавливается в "0".
  
• Если текущая стоимость больше предыдущей: пчела увеличивает вероятность оставаться у источника пищи. Если "pab" превышает "1", оно устанавливается в "1".
  
• Если текущая стоимость превышает лучшую стоимость: если текущая стоимость превысила лучшее значение, вероятность оставаться у источника устанавливается на максимальное значение "1".
  

2. Переход в состояние "Эксплуатирующий" или "Исследователь":

•  Если текущая стоимость превышает на 20% среднюю по популяции: пчела переходит в состояние "Эксплуатирующий" (stateSource), что означает, что она нашла хороший источник пищи. Вероятность оставаться у источника устанавливается на "1".
  
• Если текущая стоимость меньше средней: пчела переходит в состояние "Исследователь" (stateSearch). Это сигнализирует о необходимости поиска новых источников пищи.
  

3. Случайное направление поиска:

•  В случае перехода в состояние "Исследователь": пчела получает случайные направления для поиска новых источников пищи.
  

4. Инициализация параметров поиска:

• Устанавливается размер шага для движения агента, а также счетчик поиска, который отслеживает количество сделанных шагов в поисках пищи.

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

//——————————————————————————————————————————————————————————————————————————————

void C_AO_ABHA::ChangingStateForExperienced (S_ABHA_Agent &agent)
{

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

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

  if (agent.cost < agent.prevCost)
  {
    agent.pab -= abandonmentRate;

    if (agent.pab < 0.0) agent.pab = 0.0;
  }

  if (agent.cost > agent.prevCost)
  {

    agent.pab += abandonmentRate;

    if (agent.pab > 1.0) agent.pab = 1.0;
  }

  if (agent.cost > agent.bestCost) agent.pab = 1.0;

  if (agent.cost > avgCost * 1.2)
  {

    agent.state = S_ABHA_Agent::stateSource;

    agent.pab = 1;
  }

  else

    if (agent.cost < avgCost)
    {

      agent.state = S_ABHA_Agent::stateSearch;

      for (int c = 0; c < coords; c++)
      {

        agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c]));
      }

      agent.stepSize        = initialStepSize;

      agent.searchCounter   = 0;
    }
}
//——————————————————————————————————————————————————————————————————————————————

Теперь давайте подробно разберем код метода "ChangingStateForSearch" из класса "C_AO_ABHA", который управляет поведением агента пчелы в процессе поиска источника пищи. Метод выполняет следующие шаги:

1. Сравнение текущей стоимости с предыдущей:

• Если текущее значение "agent.cost" меньше предыдущего "agent.prevCost", это означает, что пчела отдаляется от хорошего источника. В этом случае:
• Пчела изменяет свое направление, генерируя случайные значения для каждого направления координаты с помощью функции "u.RNDfromCI".
• Устанавливается начальный размер шага "initialStepSize", пчела готова продолжать исследование.
• Увеличение счетчика поиска "searchCounter" позволяет отслеживать количество попыток поиска.

2. Сравнение текущей стоимости с лучшей:

• Если текущее значение больше лучшего "agent.bestCost", это означает, что пчела нашла более выгодный источник пищи. В этом случае:
• Размер шага уменьшается на заданный коэффициент "stepSizeReductionFactor", что указывает на необходимость более мелкого шага для уточнения найденного решения.
• Счетчик поиска сбрасывается в "0", так как пчела нашла более выгодный источник.

3. Проверка на максимальное количество попыток поиска:

• Если счетчик поиска достигает максимального числа попыток "maxSearchAttempts", это означает, что пчела не нашла ничего выгодного за определенное количество попыток. В этом случае:
• Счетчик поиска сбрасывается в "0".
• Пчела переходит в состояние "Новичок" (stateNovice), это означает, что она должна начать поиск заново.

4. Проверка на хороший источник пищи:

• Если текущее значение превышает на 20% среднюю стоимость "avgCost", это указывает на то, что пчела обнаружила хороший источник пищи. В этом случае:
• Пчела переходит в состояние "Эксплуатирующий" (stateSource), это означает, что она будет в дальнейшем оценивать прибыльность источника.
• Вероятность оставаться у источника "pab" устанавливается на "1", пчела будет более склонна оставаться на этом источнике.

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

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ABHA::ChangingStateForSearch (S_ABHA_Agent &agent)
{
  //Текущая стоимость  : Пчела использует текущее значение приспособленности для оценки своего текущего положения и для принятия решения о том, стоит ли продолжать поиск или изменять направление
  //Предыдущее значение: Пчела сравнивает текущее значение с предыдущим, чтобы определить, улучшилось ли положение.Если текущее значение лучше, она может продолжить в том же направлении.
  //Лучшее значение    : Пчела использует лучшее значение для определения, является ли текущий источник пищи более выгодным, чем предыдущие.Это помогает ей принимать решения о том, стоит ли оставаться на месте или продолжать поиск.

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

  if (agent.cost < agent.prevCost)
  {
    for (int c = 0; c < coords; c++)
    {
      agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c]));
    }

    agent.stepSize = initialStepSize;
    agent.searchCounter++;
  }

  if (agent.cost > agent.bestCost)
  {
    agent.stepSize *= stepSizeReductionFactor;
    agent.searchCounter = 0;
  }

  if (agent.searchCounter >= maxSearchAttempts)
  {
    agent.searchCounter = 0;
    agent.state = S_ABHA_Agent::stateNovice;
    return;
  }

  if (agent.cost > avgCost * 1.2)
  {
    agent.state = S_ABHA_Agent::stateSource;
    agent.pab = 1;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Метод "ChangingStateForSource" из класса "C_AO_ABHA" управляет поведением агента пчелы в процессе эксплуатации источника пищи. Общая структура метода:

1. Переход в состояние "Исследователь":

• Если текущее значение "agent.cost" ниже средней стоимости "avgCost", это указывает на то, что текущий источник пищи невыгоден.
• Пчела уменьшает вероятность оставаться у источника "pab" на значение "abandonmentRate", то есть она становится менее склонной оставаться на текущем источнике.
• Если случайное значение, полученное от "u.RNDprobab", превышает "agent.pab", пчела решает перейти в состояние "Исследователь" (stateSearch):
• Сбрасывается вероятность "pab = 0".
• Пчела изменяет свое направление, генерируя случайные значения для каждой координаты с помощью "u.RNDfromCI".
•  Устанавливается начальный размер шага "initialStepSize", и счетчик поиска "searchCounter" сбрасывается на "0".

3. Переход в состояние "Опытный":

• Если текущее значение "agent.cost" превышает лучшее значение "agent.bestCost", это означает, что текущий источник пищи подтверждает свою прибыльность.
• В этом случае пчела переходит в состояние "Опытный" (stateExperienced) и она будет в дальнейшем передавать информацию о хорошем источнике другим пчелам.
• Вероятность оставаться у источника "pab" устанавливается на "1", пчела будет оставаться на этом источнике с максимально возможной вероятностью.

Метод "ChangingStateForSource" управляет поведением пчелы в состоянии эксплуатации источника пищи. Метод позволяет пчеле принимать решение о том, стоит ли продолжать оставаться на текущем источнике или искать новый. При этом метод учитывает как текущую стоимость, так и лучшие достижения.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ABHA::ChangingStateForSource      (S_ABHA_Agent &agent)
{
  //Текущая стоимость  : Если текущее значение ниже порогового, она может решить, что источник недостаточно хорош и начать поиск нового.
  //Предыдущее значение: Пчела может использовать предыдущее значение для сравнения и определения, улучшилась ли ситуация. Если текущее значение хуже, это может сигнализировать о необходимости изменения стратегии.
  //Лучшее значение    : Пчела использует лучшее значение для принятия решения о том, стоит ли продолжать эксплуатацию текущего источника пищи или искать новый, более выгодный.

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

  if (agent.cost < avgCost)
  {
    agent.pab -= abandonmentRate;

    if (u.RNDprobab () > agent.pab)
    {
      agent.state = S_ABHA_Agent::stateSearch;
      agent.pab = 0;

      for (int c = 0; c < coords; c++)
      {
        agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c]));
      }

      agent.stepSize      = initialStepSize;
      agent.searchCounter = 0;
    }
  }

  if (agent.cost > agent.bestCost)
  {
    agent.state = S_ABHA_Agent::stateExperienced;
    agent.pab = 1;
  }
}
//—————————————————————————————————————————————————————————————————————————————

Метод "CalculateProbabilities" в классе "C_AO_ABHA" отвечает за вычисление вероятностей различных действий для каждого агента (пчелы) на основе их текущих стоимостей. Метод выполняет следующие шаги:

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

• maxCost инициализируется минимально возможным значением, чтобы гарантировать, что любая стоимость агента будет больше этого значения.
• minCost инициализируется максимальным значением, чтобы любая стоимость агента могла быть меньше этого значения.

2. Поиск максимальной и минимальной стоимости:

• Цикл проходит по всем агентам (пчелам) в популяции "popSize".
• Внутри цикла происходит сравнение текущей стоимости агента с "maxCost" и "minCost", обновляя их значения при необходимости.

3. Вычисление диапазона стоимостей:

• costRange представляет собой разницу между максимальной и минимальной стоимостью, что позволяет нормализовать вероятности.

4. Вычисление вероятностей для каждого агента:

• p_si - вероятность для агента, основанная на его стоимости. Чем выше стоимость, тем выше вероятность (нормализуется по диапазону).
• p_srs - вероятность случайного поиска, заданная заранее.
• p_rul - вероятность следования танцу. Это означает, что чем выше вероятность оставаться у источника, тем ниже вероятность следования танцу.
• p_ab - вероятность оставаться у источника, равная "pab" агента.

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

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

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ABHA::CalculateProbabilities ()
{
  double maxCost = -DBL_MAX;
  double minCost =  DBL_MAX;

  for (int i = 0; i < popSize; i++)
  {
    if (agents [i].cost > maxCost) maxCost = agents [i].cost;
    if (agents [i].cost < minCost) minCost = agents [i].cost;
  }

  double costRange = maxCost - minCost;

  for (int i = 0; i < popSize; i++)
  {
    agents [i].p_si = (maxCost - agents [i].cost) / costRange;

    agents [i].p_srs = randomSearchProbability; // вероятность случайного поиска
    agents [i].p_rul = 1.0 - agents [i].pab;    // Вероятность следования танцу
    agents [i].p_ab  = agents [i].pab;          // Вероятность оставаться у источника

    double sum = agents [i].p_srs + agents [i].p_rul + agents [i].p_ab;

    agents [i].p_srs /= sum;
    agents [i].p_rul /= sum;
    agents [i].p_ab  /= sum;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Метод "CalculateAverageCost" в классе "C_AO_ABHA" предназначен для вычисления средней стоимости "average cost" всех агентов пчел в популяции. Эта информация необходима для анализа состояния популяции и принятия решений в рамках алгоритма. Средняя стоимость служить индикатором успешности агентов, а также используется в дальнейших вычислениях.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ABHA::CalculateAverageCost ()
{
  double totalCost = 0;

  for (int i = 0; i < popSize; i++)
  {
    totalCost += agents [i].cost;
  }

  avgCost = totalCost / popSize;
}
//———————

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

Распечатка работы алгоритма ABHA:

ABHA|Artificial Bee Hive Algorithm|10.0|10.0|0.1|0.1|0.99|0.5|
=============================
5 Hilly's; Func runs: 10000; result: 0.8413125195861497
25 Hilly's; Func runs: 10000; result: 0.5422730855489947
500 Hilly's; Func runs: 10000; result: 0.2630407626746883
=============================
5 Forest's; Func runs: 10000; result: 0.8785786358650522
25 Forest's; Func runs: 10000; result: 0.47779307049664316
500 Forest's; Func runs: 10000; result: 0.17181208858518054
=============================
5 Megacity's; Func runs: 10000; result: 0.5092307692307693
25 Megacity's; Func runs: 10000; result: 0.3387692307692307
500 Megacity's; Func runs: 10000; result: 0.1039692307692317
=============================
All score: 4.12678 (45.85%)

Мы закончили написание кода и провели детальный анализ всех компонентов алгоритма ABHA, теперь переходим непосредственно к испытаниям работы алгоритма на тестовых функциях и оценим его эффективность.  На визуализации работы алгоритма можно заметить достаточно сильный разброс в результатах тестирования. На

  ABHA на тестовой функции Hilly.

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

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

Алгоритм по результатам проведенных исследований занимает уверенное место в самой середине рейтинговой таблицы.

№	AO	Description	Hilly			Hilly final	Forest			Forest final	Megacity (discrete)			Megacity final	Final result	% of MAX
			10 p (5 F)	50 p (25 F)	1000 p (500 F)		10 p (5 F)	50 p (25 F)	1000 p (500 F)		10 p (5 F)	50 p (25 F)	1000 p (500 F)
1	ANS	across neighbourhood search	0,94948	0,84776	0,43857	2,23581	1,00000	0,92334	0,39988	2,32323	0,70923	0,63477	0,23091	1,57491	6,134	68,15
2	CLA	code lock algorithm	0,95345	0,87107	0,37590	2,20042	0,98942	0,91709	0,31642	2,22294	0,79692	0,69385	0,19303	1,68380	6,107	67,86
3	(P+O)ES	(P+O) evolution strategies	0,92256	0,88101	0,40021	2,20379	0,97750	0,87490	0,31945	2,17185	0,67385	0,62985	0,18634	1,49003	5,866	65,17
4	CTA	comet tail algorithm	0,95346	0,86319	0,27770	2,09435	0,99794	0,85740	0,33949	2,19484	0,88769	0,56431	0,10512	1,55712	5,846	64,96
5	SDSm	stochastic diffusion search M	0,93066	0,85445	0,39476	2,17988	0,99983	0,89244	0,19619	2,08846	0,72333	0,61100	0,10670	1,44103	5,709	63,44
6	ESG	evolution of social groups	0,99906	0,79654	0,35056	2,14616	1,00000	0,82863	0,13102	1,95965	0,82333	0,55300	0,04725	1,42358	5,529	61,44
7	SIA	simulated isotropic annealing	0,95784	0,84264	0,41465	2,21513	0,98239	0,79586	0,20507	1,98332	0,68667	0,49300	0,09053	1,27020	5,469	60,76
8	ACS	artificial cooperative search	0,75547	0,74744	0,30407	1,80698	1,00000	0,88861	0,22413	2,11274	0,69077	0,48185	0,13322	1,30583	5,226	58,06
9	TSEA	turtle shell evolution algorithm	0,96798	0,64480	0,29672	1,90949	0,99449	0,61981	0,22708	1,84139	0,69077	0,42646	0,13598	1,25322	5,004	55,60
10	DE	differential evolution	0,95044	0,61674	0,30308	1,87026	0,95317	0,78896	0,16652	1,90865	0,78667	0,36033	0,02953	1,17653	4,955	55,06
11	CRO	chemical reaction optimisation	0,94629	0,66112	0,29853	1,90593	0,87906	0,58422	0,21146	1,67473	0,75846	0,42646	0,12686	1,31178	4,892	54,36
12	BSA	bird swarm algorithm	0,89306	0,64900	0,26250	1,80455	0,92420	0,71121	0,24939	1,88479	0,69385	0,32615	0,10012	1,12012	4,809	53,44
13	HS	harmony search	0,86509	0,68782	0,32527	1,87818	0,99999	0,68002	0,09590	1,77592	0,62000	0,42267	0,05458	1,09725	4,751	52,79
14	SSG	saplings sowing and growing	0,77839	0,64925	0,39543	1,82308	0,85973	0,62467	0,17429	1,65869	0,64667	0,44133	0,10598	1,19398	4,676	51,95
15	(PO)ES	(PO) evolution strategies	0,79025	0,62647	0,42935	1,84606	0,87616	0,60943	0,19591	1,68151	0,59000	0,37933	0,11322	1,08255	4,610	51,22
16	BSO	brain storm optimization	0,93736	0,57616	0,29688	1,81041	0,93131	0,55866	0,23537	1,72534	0,55231	0,29077	0,11914	0,96222	4,498	49,98
17	WOAm	wale optimization algorithm M	0,84521	0,56298	0,26263	1,67081	0,93100	0,52278	0,16365	1,61743	0,66308	0,41138	0,11357	1,18803	4,476	49,74
18	AEFA	artificial electric field algorithm	0,87700	0,61753	0,25235	1,74688	0,92729	0,72698	0,18064	1,83490	0,66615	0,11631	0,09508	0,87754	4,459	49,55
19	ACOm	ant colony optimization M	0,88190	0,66127	0,30377	1,84693	0,85873	0,58680	0,15051	1,59604	0,59667	0,37333	0,02472	0,99472	4,438	49,31
20	BFO-GA	bacterial foraging optimization - ga	0,89150	0,55111	0,31529	1,75790	0,96982	0,39612	0,06305	1,42899	0,72667	0,27500	0,03525	1,03692	4,224	46,93
21	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
22	ASBO	adaptive social behavior optimization	0,76331	0,49253	0,32619	1,58202	0,79546	0,40035	0,26097	1,45677	0,26462	0,17169	0,18200	0,61831	3,657	40,63
23	MEC	mind evolutionary computation	0,69533	0,53376	0,32661	1,55569	0,72464	0,33036	0,07198	1,12698	0,52500	0,22000	0,04198	0,78698	3,470	38,55
24	IWO	invasive weed optimization	0,72679	0,52256	0,33123	1,58058	0,70756	0,33955	0,07484	1,12196	0,42333	0,23067	0,04617	0,70017	3,403	37,81
25	Micro-AIS	micro artificial immune system	0,79547	0,51922	0,30861	1,62330	0,72956	0,36879	0,09398	1,19233	0,37667	0,15867	0,02802	0,56335	3,379	37,54
26	COAm	cuckoo optimization algorithm M	0,75820	0,48652	0,31369	1,55841	0,74054	0,28051	0,05599	1,07704	0,50500	0,17467	0,03380	0,71347	3,349	37,21
27	SDOm	spiral dynamics optimization M	0,74601	0,44623	0,29687	1,48912	0,70204	0,34678	0,10944	1,15826	0,42833	0,16767	0,03663	0,63263	3,280	36,44
28	NMm	Nelder-Mead method M	0,73807	0,50598	0,31342	1,55747	0,63674	0,28302	0,08221	1,00197	0,44667	0,18667	0,04028	0,67362	3,233	35,92
29	FAm	firefly algorithm M	0,58634	0,47228	0,32276	1,38138	0,68467	0,37439	0,10908	1,16814	0,28667	0,16467	0,04722	0,49855	3,048	33,87
30	GSA	gravitational search algorithm	0,64757	0,49197	0,30062	1,44016	0,53962	0,36353	0,09945	1,00260	0,32667	0,12200	0,01917	0,46783	2,911	32,34
31	BFO	bacterial foraging optimization	0,61171	0,43270	0,31318	1,35759	0,54410	0,21511	0,05676	0,81597	0,42167	0,13800	0,03195	0,59162	2,765	30,72
32	ABC	artificial bee colony	0,63377	0,42402	0,30892	1,36671	0,55103	0,21874	0,05623	0,82600	0,34000	0,14200	0,03102	0,51302	2,706	30,06
33	BA	bat algorithm	0,59761	0,45911	0,35242	1,40915	0,40321	0,19313	0,07175	0,66810	0,21000	0,10100	0,03517	0,34617	2,423	26,93
34	SA	simulated annealing	0,55787	0,42177	0,31549	1,29513	0,34998	0,15259	0,05023	0,55280	0,31167	0,10033	0,02883	0,44083	2,289	25,43
35	IWDm	intelligent water drops M	0,54501	0,37897	0,30124	1,22522	0,46104	0,14704	0,04369	0,65177	0,25833	0,09700	0,02308	0,37842	2,255	25,06
36	PSO	particle swarm 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
37	Boids	boids algorithm	0,43340	0,30581	0,25425	0,99346	0,35718	0,20160	0,15708	0,71586	0,27846	0,14277	0,09834	0,51957	2,229	24,77
38	MA	monkey algorithm	0,59107	0,42681	0,31816	1,33604	0,31138	0,14069	0,06612	0,51819	0,22833	0,08567	0,02790	0,34190	2,196	24,40
39	SFL	shuffled frog-leaping	0,53925	0,35816	0,29809	1,19551	0,37141	0,11427	0,04051	0,52618	0,27167	0,08667	0,02402	0,38235	2,104	23,38
40	FSS	fish school search	0,55669	0,39992	0,31172	1,26833	0,31009	0,11889	0,04569	0,47467	0,21167	0,07633	0,02488	0,31288	2,056	22,84
41	RND	random	0,52033	0,36068	0,30133	1,18234	0,31335	0,11787	0,04354	0,47476	0,25333	0,07933	0,02382	0,35648	2,014	22,37
42	GWO	grey wolf optimizer	0,59169	0,36561	0,29595	1,25326	0,24499	0,09047	0,03612	0,37158	0,27667	0,08567	0,02170	0,38403	2,009	22,32
43	CSS	charged system search	0,44252	0,35454	0,35201	1,14907	0,24140	0,11345	0,06814	0,42299	0,18333	0,06300	0,02322	0,26955	1,842	20,46
44	EM	electroMagnetism-like algorithm	0,46250	0,34594	0,32285	1,13129	0,21245	0,09783	0,10057	0,41085	0,15667	0,06033	0,02712	0,24412	1,786	19,85

Выводы

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

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

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

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

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

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

Плюсы и минусы алгоритма искусственного пчелиного улья (ABHA):

Плюсы:

1. Хорошие результаты на задачах малой размерности.
2. Хорошие результаты на дискретных функциях.
   

Минусы:

1. Сложная логика и реализация алгоритма.
2. Невысокая сходимость на задачах большой размерности на гладких функциях.
   
3. Большое количество внешних параметров.
   

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

• github: https://github.com/JQSakaJoo/Population-optimization-algorithms-MQL5
• CodeBase: https://www.mql5.com/ru/code/49355