Алгоритм искусственного пчелиного улья — Artificial Bee Hive Algorithm (ABHA): Теория и методы
525
0
1. Введение
В одной из предыдущих статей мы уже рассматривали алгоритм пчелиной колонии (ABC), который является ярким примером природы, вдохновляющей на создание эффективных вычислительных методов. Пчелиная колония — это не просто группа насекомых, а высокоорганизованная система, в которой каждая пчела выполняет свою уникальную роль. Некоторые пчелы становятся разведчиками, исследующими окрестности в поисках пищи, в то время как другие занимают роли сборщиков, которые собирают нектар и пыльцу. Эта форма сотрудничества позволяет колонии быть более эффективной в поиске ресурсов, чем если бы каждая пчела действовала индивидуально.
Новый алгоритм искусственного пчелиного улья в данной статье более глубоко и комплексно раскрывает процесс добычи пищи пчелами, демонстрируя, как коллективное взаимодействие и распределение ролей способствуют поиску новых источников пропитания. Он демонстрирует, как взаимодействие между агентами может привести к более эффективным результатам. В этом алгоритме более детально рассматриваются отдельные роли для каждой особи в пчелиной семье.
Основная цель ABHA заключается в нахождении оптимальных решений в многомерных пространствах, где функции могут иметь множество локальных минимумов и максимумов. Это делает задачу оптимизации особенно сложной, так как традиционные методы могут застревать в локальных экстремумах, не достигая глобального оптимума. Алгоритм ABHA черпает вдохновение из продуктивных стратегий поиска пищи, которые используют пчелы. В природе пчелы применяют коллективные методы, позволяющие им эффективно находить источники нектара, и этот принцип был адаптирован для создания алгоритма, который может улучшать процесс поиска оптимальных решений.
В структуре ABHA предусмотрены различные состояния, которые отражают динамику поведения пчел. Одним из таких состояний является "опытное состояние", в ходе которого пчелы обмениваются информацией о найденных источниках пищи. Это состояние способствует накоплению знаний о наиболее продуктивных областях многомерного пространства. Другим важным состоянием является "поисковое состояние", когда пчелы активно исследуют пространство в поисках лучших источников, используя информацию, полученную от своих сородичей.
Алгоритм искусственного улья (Artificial Beehive Algorithm, ABHA) был разработан в 2009 году группой исследователей, возглавляемой Андре Муньосом и нацелен на решение задач непрерывной оптимизации.
2. Реализация алгоритма
ABHA — это интересный метод, который использует аналогию с поведением пчел для решения сложных задач оптимизации в непрерывных пространствах поиска. Давайте рассмотрим основные концепции алгоритма:
1. Моделирование поведения пчел:
- ABHA основан на модели индивидуального поведения пчел. Каждый агент (пчела) в алгоритме следует набору поведенческих правил, чтобы определить, какие действия ему следует предпринимать.
2. Взаимодействие внутри улья:
- Основной акцент ABHA — на взаимодействии между пчелами.
- Пчелы обмениваются информацией о найденных решениях.
| Состояние пчелы | Типы поведения |
|---|---|
| Новичок (Novice state) | Находится в "улье" (абстрактная позиция, где происходит обмен информацией) и не имеет информации об источниках пищи. |
| Опытный (Experimented state) | Имеет информацию об источнике пищи и может делиться этой информацией. |
| Исследователь (Search state) | Ищет источник пищи лучше, чем текущий. |
| Эксплуатирующий (Food source state) | Оценивает прибыльность своего источника пищи и решает, стоит ли его объявлять. |
Каждое из этих состояний отражает различные аспекты поведения пчел в поиске и эксплуатации источников пищи. Каждое состояние пчелы означает набор правил, которым следует соответствующая пчела:
| Состояние пчелы | Правила изменения положения пчелы в пространстве |
|---|---|
| Новичок | Пчела может начать случайный поиск или следовать за танцем, если он доступен. Если информация об источнике пищи недоступна, она может начать случайный поиск. |
| Опытный | Если информация об источнике пищи действительна, пчела может передавать ее другим пчелам через танец. Если информация недействительна, она может начать случайный поиск. |
| Исследователь | Пчела изменяет свое положение, используя информацию о направлении и размере шага, пока не найдет лучший источник пищи. |
| Эксплуатирующий | Пчела оценивает прибыльность источника и, если он не удовлетворяет критериям, может изменить направление поиска. |
Не все пчёлы могут делиться информацией об источнике пищи, и не каждая пчела может получать информацию от других сородичей, имеющих эту возможность. Существуют два типа пчёл, которые имеют право получать или передавать информацию об источнике пищи:
1. Обладающие способностью передавать информацию:
- Опытный – может передавать информацию другим пчелам через танец, если информация об источнике пищи действительна.
2. Обладающие способностью получать информацию через танец других пчел:
- Новичок – может следовать за танцем, если он доступен, чтобы получить информацию об источниках пищи.
- Опытный – может получать информацию через танец от других пчел и имеет доступ к информации об источниках пищи.
Пчелы могут изменять свои состояния в зависимости от условий, связанных с их опытом и информацией об источниках пищи. Ниже перечислим типы пчел и условия, при которых они могут переходить из одного состояния в другое:
1. Новичок
- В опытного. Если новичок получает информацию о высокоприбыльном источнике пищи (например, через танец от других пчел), он может перейти в состояние опытного.
- В исследователя. Если новичок не получает информации об источниках пищи, он может начать поиск самостоятельно и перейти в состояние исследователя.
2. Опытный
- В исследователя. Если информация о текущем источнике пищи оказывается недостаточно хорошей (например, текущее значение приспособленности ниже порогового), пчела может перейти в состояние исследователя для поиска новых источников.
- В эксплуатирующего. Если информация об источнике пищи подтверждается (например, текущее значение приспособленности высокое и стабильное), пчела может перейти в состояние эксплуатирующего для более глубокого анализа источника.
3. Исследователь
- В эксплуатирующего. Если исследователь находит источник пищи с хорошими характеристиками (например, текущее значение приспособленности лучше порогового), он может перейти в состояние эксплуатирующего для периодической оценки прибыльности источника.
- В новичка. Если исследователь не находит никаких источников пищи или информация оказывается недостаточно ценной, он может вернуться в состояние новичка.
4. Эксплуатирующий
- В исследователя. Если текущий источник пищи оказывается невыгодным (например, текущее значение приспособленности хуже порогового), пчела может перейти в состояние исследователя для поиска новых источников.
- В опытного. Если эксплуатирующий находит источник пищи, который подтверждает свою прибыльность, он может перейти в состояние опытного для передачи информации другим пчелам.
Эти переходы между состояниями позволяют алгоритму динамично изменять стратегию поиска в зависимости от положения отдельных особей в пространстве решений и эффективно обмениваться информацией об источниках пищи.
Немаловажную роль в алгоритме играет понятие "источника пищи" и "танца" пчел. В контексте алгоритма "источник пищи" представляет собой потенциальное решение оптимизационной задачи:
1. Каждый "источник пищи" соответствует определенному положению, которое представляет собой возможное решение оптимизационной задачи в пространстве поиска.
2. Качество или "прибыльность" источника пищи определяется значением целевой функции в этой точке. Чем больше значение целевой функции, тем "прибыльнее" источник пищи.
3. Пчелы в алгоритме ищут и эксплуатируют наиболее "прибыльные" источники пищи, то есть те положения, которые соответствуют наилучшим значениям целевой функции.
4. Истощение источника пищи означает, что в данной точке пространства поиска уже не может быть найдено лучшее решение, и пчелы должны переключиться на поиск новых, более перспективных областей.
В алгоритме "танец" представляет собой способ обмена информацией между пчелами о найденных "источниках пищи", как это происходит:
- Когда пчела находит перспективный "источник пищи", она возвращается в "улей" и исполняет "танец".
- Продолжительность "танца" зависит от "прибыльности" найденного источника пищи - чем лучше решение, тем дольше будет "танец".
- Другие пчелы в улье могут прослушать этот "танец" и получить информацию об источнике пищи. Вероятность того, что пчела последует за "танцем", зависит от "прибыльности" источника.
Таким образом, "источник пищи" в алгоритме ABHA является аналогом потенциального решения оптимизационной задачи, а его "прибыльность" определяется значением целевой функции в соответствующей точке пространства поиска, а "танец" служит способом передачи информации между пчелами о наиболее перспективных решениях, найденных в процессе поиска.
В алгоритме ABHA каждый тип пчел использует значения приспособленности (или стоимости) на предыдущем шаге, на текущем и лучшее значение приспособленности следующим образом:
| Состояние пчелы | Новичок | Опытный | Исследователь | Эксплуатирующий |
|---|---|---|---|---|
| Текущая стоимость | Используется для перехода в состояние либо Опытный, либо Исследователь. | Если текущее значение высокое и информация действительна, она может передавать эту информацию другим пчелам через танец. | Пчела использует текущее значение приспособленности для оценки своего текущего положения и для принятия решения о том, стоит ли продолжать поиск или изменять направление. | Если текущее значение ниже порогового, она может решить, что источник недостаточно хорош и начать поиск нового. |
| Предыдущее значение | Не используется | Пчела сравнивает текущее значение с предыдущим, чтобы определить, улучшилась ли ситуация. Если текущее значение лучше, это может повысить вероятность передачи информации. | Пчела сравнивает текущее значение с предыдущим, чтобы определить, улучшилось ли положение. Если текущее значение лучше, она может продолжить в том же направлении. | Не используется |
| Лучшее значение | Не используется | Пчела может использовать лучшее значение для оценки, стоит ли продолжать исследование данного источника пищи или искать новый. | Пчела использует лучшее значение для определения, является ли текущий источник пищи более выгодным, чем текущее. Это помогает ей принимать решения о том, стоит ли оставаться на месте или продолжать поиск. | Пчела использует лучшее значение для принятия решения о том, стоит ли продолжать эксплуатацию текущего источника пищи или перейти в состояние опытного. |
Каждый тип пчел использует информацию о приспособленности на разных итерациях для принятия решений и переходе в разные состояния.
В алгоритме вероятности выбора действий, такие как вероятность случайного поиска, вероятность следования танцу и вероятность отказа от источника (или оставаться возле источника), рассчитываются динамически на протяжении всего процесса оптимизации. Эти вероятности помогают агентам (пчелам) принимать решения о том, как действовать в зависимости от текущей информации и состояния окружающей среды.
Расчет вероятностей:
1. Вероятность случайного поиска (Psrs). Насколько вероятно, что пчела начнет случайный поиск вместо того, чтобы следовать за танцем или оставаться на текущем источнике пищи.
2. Вероятность следования танцу (Prul). Насколько вероятно, что пчела будет следовать за танцем другой пчелы
3. Вероятность отказа от источника (Pab). Насколько вероятно, что пчела останется у текущего источника пищи, или откажется от него.
Пчелы в разных состояниях используют вероятности по-разному, причём вероятности для каждого состояния также отличаются:
1. Новичок:
- Psrs: высока, так как пчела не имеет информации о других источниках и может начать случайный поиск.
- Prul: может быть использована, если другие пчелы танцуют, но вероятность будет зависеть от доступной информации.
- Pab: не применяется, так как пчела еще не нашла источник пищи.
2. Опытный:
- Psrs: низка, так как пчела уже имеет информацию об источнике.
- Prul: используется для передачи информации другим пчелам, если информация об источнике считается валидной.
- Pab: может быть использована для принятия решения о том, стоит ли продолжать исследовать текущий источник или отказаться от него, если его прибыль низка.
3. Исследователь:
- Psrs: может быть использована, если пчела не находит удовлетворительных источников.
- Prul: может быть использована, если пчела решает следовать за танцем другой пчелы, чтобы найти новый источник.
- Pab: применяется для оценки, стоит ли продолжать поиск или вернуться к "гнезду".
4. Эксплуатирующий:
- Psrs: низка, так как пчела уже нашла источник.
- Prul: используется для передачи информации о валидном источнике другим пчелам, если источник считается прибыльным.
- Pab: высока, если источник не приносит удовлетворительных результатов, что может привести к решению отказаться от него.
Надеюсь, что мы охватили все нюансы поведения пчел и теперь можем приступить к составлению псевдокода.
Инициализация:
Установить параметры алгоритма (popSize, maxSearchAttempts, abandonmentRate, и т.д.)
Создать популяцию из popSize агентов со случайными позициями
Установить начальное состояние каждого агента как "Новичок"
Главный цикл:
Пока не достигнуто условие остановки:
Для каждого агента:
Выполнить действие в зависимости от текущего состояния:
"Новичок": случайный поиск или следование за танцем
"Опытный": случайный поиск, следование за танцем или локальный поиск
"Исследователь": движение в заданном направлении
"Эксплуатирующий": локальный поиск вокруг лучшей позиции
Оценить fitness агента
Обновить лучшее глобальное решение, если найдено
Рассчитать вероятности и среднюю стоимость решений
Для каждого агента:
Обновить состояние:
"Новичок": переход в "Опытный" или "Исследователь"
"Опытный": возможный переход в "Эксплуатирующий" или "Исследователь"
"Исследователь": возможный переход в "Новичок" или "Эксплуатирующий"
"Эксплуатирующий": возможный переход в "Исследователь" или "Опытный"
Обновить лучшую личную позицию и стоимость
Рассчитать вероятности для агентов
Рассчитать среднюю стоимость
Теперь приступим к написанию кода алгоритма. Логика ABHA достаточно сложная и код объемный, поэтому будем максимально подробно описывать структуру, класс и методы, которые задействованы в работе.
Структура S_ABHA_Agent, представляет агента "пчелу" в алгоритме, основанном на поведении пчел. Описание структуры:
1. Перечисление "BeeState" определяет различные состояния пчелы:
- stateNovice - состояние новичка, когда пчела только начинает свою деятельность.
- stateExperienced - состояние опытной пчелы, которая уже имеет некоторый опыт.
- stateSearch - состояние поиска, когда пчела активно ищет источники пищи.
- stateSource - состояние нахождения возле источника и его периодическая оценка.
2. Поля структуры:
- position [] - массив текущей позиции пчелы в пространстве.
- bestPosition [] - массив лучшей найденной позиции пчелы.
- direction [] - массив вектора направления движения пчелы.
- cost - значение качества текущего источника пищи.
- prevCost - значение качества предыдущего источника пищи.
- bestCost - значение качества лучшего найденного источника пищи.
- stepSize - коэффициент размера шага пчелы при движении по координатам.
- state - текущее состояние пчелы, представленное как целое число.
- searchCounter - счетчик действий пчелы в состоянии поиска.
3. Поля структуры, задающие вероятности:
- pab - вероятность оставаться у источника пищи.
- p_si - динамическая вероятность того, что другие пчелы выберут танец этой пчелы.
- p_srs - вероятность случайного поиска.
- p_rul - вероятность следования танцу.
- p_ab - вероятность остаться возле источника пищи.
4. Метод "Init":
- Инициализирует агента, принимая на вход количество координат "coords" и начальный размер шага "initStepSize".
- Метод выделяет память для массивов, устанавливает начальные значения для всех членов структуры, включая состояние, счетчики и вероятности.
Структура "S_ABHA_Agent" служит для моделирования поведения пчелы в алгоритме, где пчела может находиться в различных состояниях, исследовать пространство в поисках пищи и взаимодействовать с другими пчелами. Инициализация структуры позволяет задать начальные параметры, необходимые для начала работы алгоритма.
//—————————————————————————————————————————————————————————————————————————————— struct S_ABHA_Agent { enum BeeState { stateNovice = 0, // Состояние новичка stateExperienced = 1, // Состояние опытной пчелы stateSearch = 2, // Состояние поиска stateSource = 3 // Состояние нахождения источника }; double position []; // Текущая позиция пчелы double bestPosition []; // Лучшая найденная позиция пчелы double direction []; // Вектор направления движения пчелы double cost; // Качество текущего источника пищи double prevCost; // Качество предыдущего источника пищи double bestCost; // Качество лучшего найденного источника пищи double stepSize; // Коэффициент шагов по всем координатам при движении пчелы int state; // Текущее состояние пчелы int searchCounter; // Счетчик действий пчелы в состоянии поиска double pab; // Вероятность оставаться у источника double p_si; // Динамическая Вероятность выбора танца этой пчелы другими пчелами double p_srs; // Вероятность случайного поиска double p_rul; // Вероятность следования танцу double p_ab; // Вероятность отказа от источника void Init (int coords, double initStepSize) { ArrayResize (position, coords); ArrayResize (bestPosition, coords); ArrayResize (direction, coords); cost = -DBL_MAX; prevCost = -DBL_MAX; bestCost = -DBL_MAX; state = stateNovice; searchCounter = 0; pab = 0; p_si = 0; p_srs = 0; p_rul = 0; p_ab = 0; stepSize = initStepSize; } }; //——————————————————————————————————————————————————————————————————————————————
Класс "C_AO_ABHA" наследуется от базового класса "C_AO", что подразумевает, что он использует функциональность, определенную в родительском классе. Описание класса:
1. Конструктор "C_AO_ABHA ()":
- Устанавливает параметры, такие как размер популяции "popSize", максимальное количество попыток поиска "maxSearchAttempts", коэффициенты для различных вероятностей и начальный размер шага "initialStepSize".
- Инициализирует массив "params", который содержит параметры алгоритма.
2. Метод "SetParams ()" устанавливает значения параметров алгоритма на основе значений, хранящихся в массиве "params".
3. Метод "Init ()" инициализирует алгоритм, принимая на вход минимальные и максимальные значения диапазона поиска, шаг поиска и количество эпох.
4. Методы "Moving ()" и "Revision ()" - эти методы предназначены для выполнения логики движения агентов (пчел) и пересмотра найденных решений.
5. Члены класса:
- maxSearchAttempts - максимальное количество попыток поиска.
- abandonmentRate - шаг изменения вероятности остаться у источника пищи.
- randomSearchProbability - вероятность случайного поиска.
- stepSizeReductionFactor - коэффициент уменьшения размера шага.
- initialStepSize - начальный размер шага.
- S_ABHA_Agent agents [] - массив агентов (пчел), участвующих в алгоритме.
- avgCost - средняя стоимость найденного решения.
6. Методы для действий пчел:
- ActionRandomSearch () - случайный поиск в заданном диапазоне.
- ActionFollowingDance () - следование за танцем другой пчелы.
- ActionMovingDirection () - перемещение в заданном направлении с учетом размера шага.
- ActionHiveVicinity () - движение в окрестностях источника пищи.
7. Методы для активности пчел в различных состояниях: StageActivityNovice (), StageActivityExperienced (), StageActivitySearch (), StageActivitySource () - определяют действия пчел в зависимости от их состояния.
8. Методы для изменения состояния пчел: ChangingStateForNovice (), ChangingStateForExperienced (), ChangingStateForSearch (), ChangingStateForSource () - изменяют состояние пчел в зависимости от их активности.
9. Методы для расчетов:
- CalculateProbabilities () - расчет вероятностей для действий пчел.
- CalculateAverageCost () - расчет средней стоимости найденных решений.
Класс "C_AO_ABHA" реализует алгоритм оптимизации, основанный на поведении пчел и охватывает различные аспекты работы пчел, такие как движение, принятие решений и изменение состояний.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_ABHA : public C_AO { public: C_AO_ABHA () { ao_name = "ABHA"; ao_desc = "Artificial Bee Hive Algorithm"; ao_link = "https://www.mql5.com/ru/articles/15347"; popSize = 10; maxSearchAttempts = 10; abandonmentRate = 0.1; randomSearchProbability = 0.1; stepSizeReductionFactor = 0.99; initialStepSize = 0.5; ArrayResize (params, 6); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "maxSearchAttempts"; params [1].val = maxSearchAttempts; params [2].name = "abandonmentRate"; params [2].val = abandonmentRate; params [3].name = "randomSearchProbability"; params [3].val = randomSearchProbability; params [4].name = "stepSizeReductionFactor"; params [4].val = stepSizeReductionFactor; params [5].name = "initialStepSize"; params [5].val = initialStepSize; } void SetParams () { popSize = (int)params [0].val; maxSearchAttempts = (int)params [1].val; abandonmentRate = params [2].val; randomSearchProbability = params [3].val; stepSizeReductionFactor = params [4].val; initialStepSize = params [5].val; } bool Init (const double &rangeMinP [], //minimum search range const double &rangeMaxP [], //maximum search range const double &rangeStepP [], //step search const int epochsP = 0); //number of epochs void Moving (); void Revision (); //---------------------------------------------------------------------------- int maxSearchAttempts; double abandonmentRate; double randomSearchProbability; double stepSizeReductionFactor; double initialStepSize; S_ABHA_Agent agents []; private: //------------------------------------------------------------------- double avgCost; //Типы действий пчел---------------------------------------------------------- double ActionRandomSearch (int coordInd); //1. Случайный поиск (случайное размещение в диапазоне координат) double ActionFollowingDance (int coordInd, double val); //2. Следование за танцем (двигаться в направлении танцора) double ActionMovingDirection (S_ABHA_Agent &agent, int coordInd); //3. Перемещение в заданном направлении с шагом double ActionHiveVicinity (int coordInd, double val); //4. Двигаться в окрестностях источника пищи //Действия пчел в различных состояниях---------------------------------------- void StageActivityNovice (S_ABHA_Agent &agent); //действия 1 или 2 void StageActivityExperienced (S_ABHA_Agent &agent); //действия 1 или 2 или 4 void StageActivitySearch (S_ABHA_Agent &agent); //действия 3 void StageActivitySource (S_ABHA_Agent &agent); //действия 4 //Изменение состояния пчел---------------------------------------------------- void ChangingStateForNovice (S_ABHA_Agent &agent); void ChangingStateForExperienced (S_ABHA_Agent &agent); void ChangingStateForSearch (S_ABHA_Agent &agent); void ChangingStateForSource (S_ABHA_Agent &agent); void CalculateProbabilities (); void CalculateAverageCost (); }; //——————————————————————————————————————————————————————————————————————————————
Метод "Init" класса "C_AO_ABHA" отвечает за инициализацию алгоритма ABHA. Давайте разберем его по частям:
1. Параметры метода:
- rangeMinP [] - массив минимальных значений для диапазона поиска. Это нижние границы для каждой переменной, которые будут оптимизироваться.
- rangeMaxP [] - массив максимальных значений для диапазона поиска. Это верхние границы для каждой переменной.
- rangeStepP [] - массив шага поиска. Это значения, которые определяют, на сколько изменяются переменные в процессе поиска.
- epochsP - количество эпох (итераций) за которые будет выполняться алгоритм.
2. Метод возвращает "true", если инициализация прошла успешно, и "false", если произошла ошибка.
Логика метода:
- Вызов метода "StandardInit" с параметрами диапазона поиска. Этот метод, выполняет стандартные операции инициализации, такие как установка границ поиска и шагов. Если инициализация не удалась, метод "Init" завершает выполнение и возвращает "false".
- Метод "ArrayResize" изменяет размер массива "agents", который представляет собой пчел (агентов) в алгоритме. Размер массива устанавливается в "popSize", что определяет количество агентов, участвующих в оптимизации.
- Цикл инициализирует каждого агента в массиве "agents". Для каждого агента вызывается метод "Init", который настраивает его начальные координаты (из массива "coords") и начальный размер шага "initialStepSize". Этот шаг определяет, насколько далеко агент может перемещаться в процессе поиска.
Метод "Init" класса "C_AO_ABHA" выполняет следующие задачи:
- Проверяет успешность стандартной инициализации параметров поиска.
- Изменяет размер массива агентов в соответствии с заданным количеством пчел.
- Инициализирует каждого агента с помощью его собственного метода "Init", устанавливая начальные параметры, необходимые для работы алгоритма.
Если все шаги выполнены успешно, метод возвращает "true", что указывает на успешную инициализацию алгоритма.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_ABHA::Init (const double &rangeMinP [], //minimum search range const double &rangeMaxP [], //maximum search range const double &rangeStepP [], //step search const int epochsP = 0) //number of epochs { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; ArrayResize (agents, popSize); for (int i = 0; i < popSize; i++) { agents [i].Init (coords, initialStepSize); } return true; } //————————————————————
Следующим разберем метод "Moving" класса "C_AO_ABHA", который реализует этап перемещения агентов в алгоритме. Метод "Moving" не принимает параметров и не возвращает значения. Он управляет перемещением агентов (пчел) в процессе оптимизации. Логика метода:
1. Первоначальная инициализация.
- Проверка переменной "revision" - если равно "false", это первый вызов метода, и необходимо инициализировать позиции агентов.
- Генерация начальных позиций - вложенные циклы перебирают всех агентов и координаты. Для каждой координаты:
- Генерируется случайное значение "val" в пределах заданного диапазона ("rangeMin" и "rangeMax").
- Это значение затем корректируется с помощью метода "SeInDiSp", который устанавливает значение в допустимый диапазон с заданным шагом.
- Устанавливаются текущая позиция и лучшая позиция агента (в начале они одинаковы).
- Генерируется случайное направление перемещения агента.
- После завершения инициализации "revision" устанавливается в "true" и метод завершается.
2. Основная логика перемещения агентов. Перемещение агентов по состояниям:
- Для каждого агента определяется его текущее состояние (новичок, опытный, исследователь или эксплуатирующий) с помощью "switch". В зависимости от состояния вызывается соответствующий метод, который управляет поведением агента (например, "StageActivityNovice", "StageActivityExperienced" и т.д.).
- После выполнения действий в зависимости от состояния, позиции агентов обновляются с использованием метода "SeInDiSp", чтобы оставаться в допустимых пределах.
3. Цикл обновляет массив "a", копируя текущие позиции агентов в соответствующие элементы массива "a".
Итоговый смысл работы метода "Moving", который управляет перемещением агентов в алгоритме ABHA. Он сначала инициализирует позиции агентов, если это первый вызов метода, а затем обновляет их позиции в зависимости от их состояния и включает в себя:
- Генерацию случайных начальных позиций.
- Определение поведения агентов в зависимости от их состояния.
- Обновление текущих позиций агентов в массиве "a".
Этот метод является ключевым и управляющим для вызова остальных методов состояний пчел для динамического поведения агентов в процессе оптимизации.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::Moving () { //---------------------------------------------------------------------------- if (!revision) { double val = 0.0; for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { val = u.RNDfromCI (rangeMin [c], rangeMax [c]); val = u.SeInDiSp (val, rangeMin [c], rangeMax [c], rangeStep [c]); agents [i].position [c] = val; agents [i].bestPosition [c] = val; agents [i].direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); a [i].c [c] = val; } } revision = true; return; } //---------------------------------------------------------------------------- for (int i = 0; i < popSize; i++) { switch (agents [i].state) { //------------------------------------------------------------------------ //Новичок case S_ABHA_Agent::stateNovice: { StageActivityNovice (agents [i]); break; } //------------------------------------------------------------------------ //Опытный case S_ABHA_Agent::stateExperienced: { StageActivityExperienced (agents [i]); break; } //------------------------------------------------------------------------ //Исследователь case S_ABHA_Agent::stateSearch: { StageActivitySearch (agents [i]); break; } //------------------------------------------------------------------------ //Эксплуатирующий case S_ABHA_Agent::stateSource: { StageActivitySource (agents [i]); break; } } //-------------------------------------------------------------------------- for (int c = 0; c < coords; c++) { agents [i].position [c] = u.SeInDiSp (agents [i].position [c], rangeMin [c], rangeMax [c], rangeStep [c]); a [i].c [c] = agents [i].position [c]; } } for (int i = 0; i < popSize; i++) for (int c = 0; c < coords; c++) a [i].c [c] = agents [i].position [c]; } //——————————————————————————————————————————————————————————————————————————————
Метод "Revision" класса "C_AO_ABHA" отвечает за обновление состояния агентов в алгоритме и выполняет несколько ключевых действий, связанных с оценкой и обновлением позиций и состояний агентов. Метод "Revision" не принимает параметров и не возвращает значений. Он служит для обновления информации о состоянии агентов и их позициях на основе производительности. Логика метода:
1. Поиск лучшего агента:
- Переменная "ind" инициализируется значением "-1", чтобы отслеживать индекс агента с наилучшей стоимостью.
- Поиск лучшего агента, цикл проходит по всем агентам "popSize":
- Если стоимость агента "a [i].f" больше текущего максимума "fB", обновляется "fB" и запоминается индекс "ind".
- Если был найден агент с лучшей стоимостью (то есть "ind" не равен "-1"), вызывается функция "ArrayCopy", которая копирует координаты лучшего агента в массив "cB".
2. Цикл проходит по всем агентам и обновляет их стоимость "agents[i].cost" на основе значений из массива "a".
3. Вызывается метод "CalculateProbabilities", который рассчитывает вероятности для каждого агента на основе их текущих стоимостей. Это используется для определения, как агенты будут действовать в следующем этапе.
4. Вызывается метод "CalculateAverageCost", который рассчитывает среднюю стоимость всех агентов, что необходимо для анализа пчелами собственно состояния и перехода в новые состояния.
5. Цикл проходит по всем агентам и в зависимости от их текущего состояния и вызывает соответствующий метод для изменения состояния агента "ChangingStateForNovice", "ChangingStateForExperienced", и т.д.
6. Цикл проходит по всем агентам и проверяет, если текущая стоимость агента больше его лучшей стоимости "bestCost":
- Если да, обновляется "bestCost" и копируется текущая позиция агента в "bestPosition".
- Предыдущая стоимость "prevCost" обновляется на текущее значение "cost".
Итоговый смысл работы метода "Revision", который отвечает за обновление информации о состоянии агентов в алгоритме и выполняет следующие ключевые действия:
1. Находит агента с наилучшей стоимостью и обновляет соответствующие переменные.
2. Обновляет стоимости всех агентов.
3. Вычисляет вероятности на основе текущих стоимостей.
4. Рассчитывает среднюю стоимость агентов.
5. Обновляет состояния агентов в зависимости от их производительности.
6. Обновляет лучшие стоимости и позиции агентов.
Этот метод является важной частью алгоритма, так как он обеспечивает адаптацию агентов на основе их успехов и позволяет им обмениваться информацией.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::Revision () { //---------------------------------------------------------------------------- int ind = -1; for (int i = 0; i < popSize; i++) { if (a [i].f > fB) { fB = a [i].f; ind = i; } } if (ind != -1) ArrayCopy (cB, a [ind].c, 0, 0, WHOLE_ARRAY); //---------------------------------------------------------------------------- for (int i = 0; i < popSize; i++) agents [i].cost = a [i].f; //---------------------------------------------------------------------------- //Посчитать вероятности для пчел по текущей стоимости CalculateProbabilities (); //---------------------------------------------------------------------------- //Посчитать среднюю стоимость CalculateAverageCost (); //---------------------------------------------------------------------------- //обновить состояния пчел (новичок, опытный, исследователь, эксплуатирующий) for (int i = 0; i < popSize; i++) { switch (agents [i].state) { case S_ABHA_Agent::stateNovice: { ChangingStateForNovice (agents [i]); break; } case S_ABHA_Agent::stateExperienced: { ChangingStateForExperienced (agents [i]); break; } case S_ABHA_Agent::stateSearch: { ChangingStateForSearch (agents [i]); break; } case S_ABHA_Agent::stateSource: { ChangingStateForSource (agents [i]); break; } } } //---------------------------------------------------------------------------- //Обновить стоимости для пчёл for (int i = 0; i < popSize; i++) { if (agents [i].cost > agents [i].bestCost) { agents [i].bestCost = agents [i].cost; ArrayCopy (agents [i].bestPosition, agents [i].position); } agents [i].prevCost = agents [i].cost; } } //——————————————————————————————————————————————————————————————————————————————
Заключение
В данной статье мы познакомились с алгоритмом пчелиного улья ABHA, разобрали детально принципы его работы, написали псевдокод алгоритма, а также описали структуру, класс, инициализацию, методы "Moving" и "Revision", в следующей статье мы продолжим написание кода алгоритма и охватим все остальные методы, а также, как обычно, проведем тестирование на тестовых функциях, подведем итоги по результатам работы алгоритма в рейтинговой таблице.
Алгоритм искусственного пчелиного улья — Artificial Bee Hive Algorithm (ABHA): Тестирование и результаты
Нейросети в трейдинге: Инъекция глобальной информации в независимые каналы (InjectTST)
Как опередить любой рынок?
Теория хаоса в трейдинге (Часть 2): Продолжаем погружение
- Бесплатные приложения для трейдинга
- 8 000+ сигналов для копирования
- Экономические новости для анализа финансовых рынков
Вы принимаете политику сайта и условия использования