Оптимизация нейробоидами — Neuroboids Optimization Algorithm 2 (NOA2)
507
0
Содержание
Введение
По мере того, как я все детальнее погружался в оптимизационные алгоритмы на протяжении нескольких лет, меня часто захватывали два параллельных вдохновения, такие как самоорганизация биологических роев и адаптивные обучающие возможности нейронных сетей. Синтез этих двух парадигм привел меня к разработке алгоритма гибридного подхода, который сочетает пространственный интеллект Boids Крейга Рейнольдса с адаптивными обучающими возможностями нейронных сетей.
Мой путь начался с наблюдения, что традиционные алгоритмы роя, хотя и подходят для исследования сложных пространств поиска, посредством коллективного поведения, часто не обладают способностью учиться на истории своих исследований. И наоборот, нейронные сети отлично справляются с изучением сложных шаблонов, но могут испытывать трудности с эффективным пространственным исследованием при непосредственном применении к задачам оптимизации. Вопрос, который побудил мое исследование, был обманчиво прост: что, если бы каждый агент в рое мог научиться улучшать свои стратегии движения с помощью выделенной нейронной сети?
Полученный алгоритм использует агентов, которые следуют классическим правилам boid сплоченности, разделения и выравнивания, что позволяет им самоорганизовываться и эффективно исследовать пространство поиска. Однако, в отличие от традиционных реализаций boid, каждый агент оснащен многослойной нейронной сетью, которая непрерывно учится на опыте агента, адаптируя свои стратегии движения к конкретным характеристикам ландшафта приспособленности. Этот уровень нейронного управления постепенно влияет на поведение боидов, переходя от стратегий, доминирующих в исследовании на ранних итерациях, к движению, ориентированному на эксплуатацию, по мере выявления перспективных регионов.
Больше всего меня во время разработки увлекало наблюдение за тем, как нейронные сети развивали различные стратегии, в зависимости от своего положения в пространстве поиска. Агенты вблизи перспективных областей развивали нейронные паттерны, которые усиливали локальную эксплуатацию, в то время как агенты в разреженных областях поддерживали исследовательское поведение. Эта возникающая специализация естественным образом возникла из индивидуальных процессов обучения, создавая рой с неоднородным, контекстно-зависимым поведением, без явной глобальной координации.
В данной статье я представлю архитектуру, детали реализации и анализ производительности алгоритма NOA2, а также демонстрацию его возможностей на различных функциях бенчмарка.
Реализация алгоритма
Возможно я повторюсь, что основная идея алгоритма нейробоидов заключается в объединении двух парадигм: коллективного интеллекта роевых алгоритмов и адаптивного обучения нейронных сетей.
В традиционном алгоритме боидов (boids), предложенном Крейгом Рейнольдсом, агенты следуют трем простым правилам: сближение (движение к центру группы), разделение (избегание столкновений) и выравнивание (согласование скорости с соседями). Эти правила создают реалистичное групповое поведение, похожее на поведение птиц в стаях. Нейробоиды расширяют эту концепцию, наделяя каждого агента индивидуальной нейронной сетью, которая обучается на основе опыта агента при исследовании пространства поиска. Эта нейронная сеть выполняет две ключевые функции:
- Адаптивное управление движением — корректирует скорость агента на основе текущего состояния и истории перемещений.
- Модификация стандартных правил боидов — динамически настраивает влияние правил сближения, разделения и выравнивания в зависимости от контекста.
В результате получается гибридный алгоритм, где каждый агент сохраняет социальное поведение, необходимое для эффективного исследования пространства, но при этом индивидуально адаптируется к ландшафту фитнес-функции через обучение. Это создает саморегулирующийся баланс между исследованием (exploration) и эксплуатацией (exploitation).
Ключевыми преимуществами такого подхода является самостоятельное обучение агентов оптимальным стратегиям движения вследствие чего алгоритм автоматически адаптируется к различным типам ландшафтов оптимизации, причем сохраняется исследование пространства, благодаря коллективному поведению без централизованного управления. Приведу простую аналогию: представьте стаю птиц, летящую в небе. Они движутся слаженно: никто не сталкивается, держатся вместе и летят в одном направлении. Такое поведение можно описать тремя простыми правилами: держись рядом со своими соседями (не отрывайся от стаи), не сталкивайся с соседями (соблюдай дистанцию) и лети в том же направлении (поддерживай общий курс).
Это основа так называемого алгоритма "боидов" (от "bird-oid" — "птицеподобный"). Каждая птица в стае не просто следует этим правилам, но и умеет учиться на своем опыте. Птица запоминает, какие действия приводили к успеху (например, находила больше пищи), а какие — нет. Со временем, она становится умнее и принимает лучшие решения о том, как лететь. Вот это и есть суть алгоритма нейробоидов: соединение простых правил группового движения со способностью каждого участника учиться на собственном опыте. "Нейро" в названии как раз и указывает на способность к обучению. Такой подход особенно интересен тем, что сочетает силу коллективного исследования (никто не пропустит важный участок) с преимуществами индивидуального обучения (каждый становится лучшим в своей области поиска).
Рисунок 1. Иллюстрация работы алгоритма NOA2
На иллюстрации представлены следующие ключевые элементы: ландшафт оптимизации, где желто-фиолетовая область представляет глобальный оптимум, оранжевая и фиолетовая области — локальные оптимумы, а контурные линии показывают "высоту" ландшафта фитнес-функции.
Различные группы агентов: синие — исследуют область глобального оптимума, фиолетовые — сконцентрированы вокруг первого локального оптимума, зеленые — исследуют второй локальный оптимум и красные — выполняют случайное исследование пространства. Стрелками показывается направление движения боидов. Красная точка отмечает текущее лучшее найденное решение.
Рисунок 2. Схема работы алгоритма NOA2
Схема включает в себя: блок инициализации (красный), Нейронную сеть боида (розовая), итерации алгоритма с подблоками (синий), адаптивные механизмы (зеленый), визуализация архитектуры нейронной сети с примерами соединений. В нижней части показаны миниатюрные диаграммы в виде структуры нейронной сети, визуализации правил движения боидов и баланса между исследованием и эксплуатацией.
Разобравшись с основной концепцией, можем приступить к описанию псевдокода алгоритма.
ИНИЦИАЛИЗАЦИЯ:
- Установите параметры поиска и создайте популяцию агентов.
- Для каждого агента: инициализируйте случайное положение, небольшую скорость, нейронную сеть (входные → скрытые → выходные слои) и пустую память опыта.
- Установите глобальную лучшую приспособленность в отрицательную бесконечность и счетчик стагнации в ноль.
ГЛАВНЫЙ ЦИКЛ:
Для каждой итерации:
ОЦЕНКА:
- Рассчитайте приспособленность для всех агентов.
- Обновите личные и глобальные лучшие позиции.
- Сохраните опыты в буферах памяти.
УПРАВЛЕНИЕ СТАГНАЦИЕЙ:
- Если улучшения нет: увеличьте исследование, время от времени перезапускайте слабых агентов.
- Иначе: постепенно снижайте уровень исследования.
НЕЙРОННАЯ ОБРАБОТКА:
- Для каждого агента:
- Прямой проход: входные данные (положение, скорость, расстояние до лучшего, приспособленность) → скрытые слои → выходы.
- Если собрано достаточно опыта и обнаружено улучшение: обновите нейронные веса.
ОБНОВЛЕНИЕ ДВИЖЕНИЯ:
- Для каждого агента:
- Рассчитайте стандартные силы бойдов (когезия, отделение, выравнивание).
- Примените нейронно-модифицированные силы и прямые нейронные коррекции.
- Добавьте компонент случайного исследования с вероятностью.
- Принудительно ограничьте скорость и учтите границы.
- Обновите положение на основе финальной скорости.
ПОДДЕРЖИВАЮЩИЕ РАСЧЕТЫ:
- Расчет массы: нормализуйте значения приспособленности, чтобы назначить массу каждому агенту.
- Когезия: двигайтесь к взвешенному центру масс ближайших агентов.
- Отделение: избегайте скученности соседей.
- Выравнивание: согласуйте скорость с ближайшими агентами.
- Нейронное обновление: упрощенное обратное распространение на основе улучшения приспособленности.
ВОЗВРАТ: глобальная лучшая позиция и приспособленность.
Теперь все подготовлено для написания кода алгоритма. Назначим Структуру "S_NeuroBoids_Agent", которая будет представлять собой нейро-боидного агента на основе нейро-сетевой архитектуры для выполнения задач оптимизации. В данной реализации агент имеет следующие ключевые компоненты и функции:
Координаты и скорости:
- x [] — текущие координаты агента.
- dx [] — текущие скорости агента.
- inputs [] — входные значения для нейронов (координаты, скорости, расстояние до лучшей известной позиции и т.д.).
- outputs [] — выходные значения нейронной сети (коррекция скоростей и параметры адаптации).
- weights [] — веса связей в нейронной сети.
- biases [] — смещения для нейронов.
- memory [] — массив для хранения предыдущих позиций и их значений фитнеса.
- memory_size — максимальный размер памяти для хранения.
- memory_index — текущий индекс в памяти.
- best_local_fitness — лучший локальный фитнес агента.
- m — масса агента.
- cB [] — координаты лучшей позиции, найденной агентом.
- fB — значение фитнес-функции для лучшей позиции.
Инициализация (Init) — все массивы и переменные инициализируются нулями или случайными значениями. Устанавливаются размеры массивов, инициализируются влияние (веса и смещения) маленькими случайными значениями.
Функции активации — Tanh, ReLU, Sigmoid различные функции активации, которые применяются в нейронной сети.
Обновление входных данных (UpdateInputs) — заполняет массив входов текущими координатами, скоростями, расстоянием до лучшей известной позиции и текущим значением фитнеса.
Прямое распространение (ForwardPass) — вычисляет выходы нейросети на основе входов, весов и смещений, применяя функции активации.
Обучение на основе опыта (Learn) — обновляет веса и смещения на основе накопленного опыта, если текущий опыт лучше предыдущих.
Запоминание опыта (MemorizeExperience) — сохраняет текущие координаты и фитнес агента в память.
Обновление лучшей позиции (UpdateBestPosition) — если текущее значение фитнеса лучше, чем найденное ранее, обновляет лучшую позицию.
//—————————————————————————————————————————————————————————————————————————————— // Структура нейро-боидного агента //—————————————————————————————————————————————————————————————————————————————— struct S_NeuroBoids_Agent { double x []; // текущие координаты double dx []; // текущие скорости double inputs []; // входы нейрона double outputs []; // выходы нейрона double weights []; // веса нейрона double biases []; // смещения нейрона double memory []; // память предыдущих позиций и их фитнесов int memory_size; // размер памяти для накопления опыта int memory_index; // текущий индекс в памяти double best_local_fitness; // лучший локальный фитнес агента double m; // масса бойда double cB []; // координаты лучшей позиции double fB; // значение фитнес-функции // Инициализация агента void Init (int coords, int neuron_size) { ArrayResize (x, coords); ArrayResize (dx, coords); ArrayInitialize (x, 0.0); ArrayInitialize (dx, 0.0); // Инициализируем структуру лучшей позиции ArrayResize (cB, coords); ArrayInitialize (cB, 0.0); fB = -DBL_MAX; // Входы: координаты, скорости, расстояние до лучшего и т.д. int input_size = coords * 2 + 2; // x, dx, dist_to_best, current_fitness ArrayResize (inputs, input_size); ArrayInitialize (inputs, 0.0); // Выходы: коррекция скоростей и адаптивные факторы для правил стаи int output_size = coords + 3; // dx_correction + 3 адаптивных параметра ArrayResize (outputs, output_size); ArrayInitialize (outputs, 0.0); // Веса и смещения для каждого выхода ArrayResize (weights, input_size * output_size); ArrayInitialize (weights, 0.0); ArrayResize (biases, output_size); ArrayInitialize (biases, 0.0); // Инициализация весов и смещений малыми случайными значениями for (int i = 0; i < ArraySize (weights); i++) { weights [i] = 0.01 * (MathRand () / 32767.0 * 2.0 - 1.0); } for (int i = 0; i < ArraySize (biases); i++) { biases [i] = 0.01 * (MathRand () / 32767.0 * 2.0 - 1.0); } // Инициализация памяти для накопления опыта memory_size = 10; ArrayResize (memory, memory_size * (coords + 1)); // координаты + фитнес ArrayInitialize (memory, 0.0); memory_index = 0; best_local_fitness = -DBL_MAX; // Инициализация массы m = 0.5; } // Функция активации - гиперболический тангенс double Tanh (double input_val) { return MathTanh (input_val); } // Функция активации ReLU double ReLU (double input_val) { return (input_val > 0.0) ? input_val : 0.0; } // Функция активации Sigmoid double Sigmoid (double input_val) { return 1.0 / (1.0 + MathExp (-input_val)); } // Обновление входов нейронной сети - исправленная версия void UpdateInputs (double &global_best [], double current_fitness, int coords_count) { int input_index = 0; // Координаты for (int c = 0; c < coords_count; c++) { inputs [input_index++] = x [c]; } // Скорости for (int c = 0; c < coords_count; c++) { inputs [input_index++] = dx [c]; } // Расстояние до лучшего глобального решения double dist_to_best = 0; for (int c = 0; c < coords_count; c++) { dist_to_best += MathPow (x [c] - global_best [c], 2); } dist_to_best = MathSqrt (dist_to_best); inputs [input_index++] = dist_to_best; // Текущая фитнес-функция inputs [input_index++] = current_fitness; } // Прямое распространение по сети void ForwardPass (int coords_count) { int input_size = ArraySize (inputs); int output_size = ArraySize (outputs); // Для каждого выхода вычисляем взвешенную сумму входов + смещение for (int o = 0; o < output_size; o++) { double sum = biases [o]; for (int i = 0; i < input_size; i++) { sum += inputs [i] * weights [o * input_size + i]; } // Применяем разные функции активации в зависимости от выхода if (o < coords_count) // Для коррекции скорости используем гиперболический тангенс { outputs [o] = Tanh (sum); } else // Для адаптивных параметров используем сигмоиду { outputs [o] = Sigmoid (sum); } } } // Обучение на основе накопленного опыта void Learn (double learning_rate, int coords_count) { if (memory_index < memory_size) return; // Недостаточно опыта // Находим лучший опыт в памяти int best_index = 0; double best_fitness = memory [coords_count]; // Первая фитнес-функция в памяти for (int i = 1; i < memory_size; i++) { double fitness = memory [i * (coords_count + 1) + coords_count]; if (fitness > best_fitness) { best_fitness = fitness; best_index = i; } } // Если текущий опыт не лучше предыдущего, не обновляем веса if (best_fitness <= best_local_fitness) return; best_local_fitness = best_fitness; // Простой метод обновления весов int input_size = ArraySize (inputs); int output_size = ArraySize (outputs); // Простая форма градиентного обновления for (int o = 0; o < output_size; o++) { for (int i = 0; i < input_size; i++) { int weight_index = o * input_size + i; if (weight_index < ArraySize (weights)) { weights [weight_index] += learning_rate * outputs [o] * inputs [i]; } } // Обновляем смещения biases [o] += learning_rate * outputs [o]; } } // Запоминаем текущий опыт (координаты и фитнес) void MemorizeExperience (double fitness, int coords_count) { int offset = memory_index * (coords_count + 1); // Запоминаем координаты for (int c = 0; c < coords_count; c++) { memory [offset + c] = x [c]; } // Запоминаем фитнес-функцию memory [offset + coords_count] = fitness; // Обновляем индекс памяти memory_index = (memory_index + 1) % memory_size; } // Обновление лучшей позиции агента void UpdateBestPosition (double current_fitness, int coords_count) { if (current_fitness > fB) { fB = current_fitness; ArrayCopy (cB, x, 0, 0, WHOLE_ARRAY); } } };
Класс "C_AO_NOA2" представляет собой реализацию алгоритма NOA2 и наследуется от базового класса "C_AO". Давайте рассмотрим структуру и ключевые аспекты этого класса подробнее.
Основные параметры:- popSize — размер популяции агентов (боидов).
- cohesionWeight, cohesionDist — вес и расстояние для правила сближения.
- separationWeight, separationDist — вес и расстояние для правила разделения.
- alignmentWeight, alignmentDist — вес и расстояние для правила выравнивания.
- maxSpeed и minSpeed — максимальная и минимальная скорости агентов.
- learningRate — скорость обучения для нейронной сети.
- neuralInfluence — влияние нейронной сети на движение агентов.
- explorationRate — вероятность случайного исследования пространства решений.
- m_stagnationCounter и m_prevBestFitness — счетчик стагнации и предыдущее лучшее значение фитнеса.
- SetParams () — метод, устанавливающий параметры алгоритма на основе значений, хранящихся в массиве "params".
- Init () — инициализация, принимает параметры для определения диапазонов значений для агентов. Этот метод настраивает начальные условия для работы алгоритма.
- Moving () — отвечает за движение агентов на основе различных правил взаимодействия.
- Revision () — используется для пересмотра состояния агентов в процессе выполнения алгоритма.
Агенты: S_NeuroBoids_Agent agent [] — массив агентов, представляющих боидов в популяции.
Приватные методы (для использования внутри класса):
- CalculateMass () — рассчитывает массу агентов.
- Cohesion () — реализует правило сближения.
- Separation () — реализует правило разделения.
- Alignment () — реализует правило выравнивания.
- LimitSpeed () — ограничивает скорость агента.
- KeepWithinBounds () — удерживает агентов в заданных границах.
- Distance () — вычисляет расстояние между двумя агентами.
- ApplyNeuralControl () — применяет управление нейронной сети к агенту.
- AdaptiveExploration() — реализует адаптивное исследование.
//—————————————————————————————————————————————————————————————————————————————— // Класс нейро-боидного алгоритма оптимизации, наследуемый от C_AO //—————————————————————————————————————————————————————————————————————————————— class C_AO_NOA2 : public C_AO { public: //-------------------------------------------------------------------- ~C_AO_NOA2 () { } C_AO_NOA2 () { ao_name = "NOA2"; ao_desc = "Neuroboids Optimization Algorithm 2 (joo)"; ao_link = "https://www.mql5.com/ru/articles/17497"; popSize = 50; // размер популяции cohesionWeight = 0.6; // вес сближения cohesionDist = 0.001; // дистанция сближения separationWeight = 0.005; // вес разделения separationDist = 0.03; // дистанция разделения alignmentWeight = 0.1; // вес выравнивания alignmentDist = 0.1; // дистанция выравнивания maxSpeed = 0.001; // максимальная скорость minSpeed = 0.0001; // минимальная скорость learningRate = 0.01; // скорость обучения нейронной сети neuralInfluence = 0.3; // влияние нейронной сети на движение explorationRate = 0.1; // вероятность случайного исследования ArrayResize (params, 12); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "cohesionWeight"; params [1].val = cohesionWeight; params [2].name = "cohesionDist"; params [2].val = cohesionDist; params [3].name = "separationWeight"; params [3].val = separationWeight; params [4].name = "separationDist"; params [4].val = separationDist; params [5].name = "alignmentWeight"; params [5].val = alignmentWeight; params [6].name = "alignmentDist"; params [6].val = alignmentDist; params [7].name = "maxSpeed"; params [7].val = maxSpeed; params [8].name = "minSpeed"; params [8].val = minSpeed; params [9].name = "learningRate"; params [9].val = learningRate; params [10].name = "neuralInfluence"; params [10].val = neuralInfluence; params [11].name = "explorationRate"; params [11].val = explorationRate; // Инициализация счетчика стагнации и предыдущего лучшего значения фитнеса m_stagnationCounter = 0; m_prevBestFitness = -DBL_MAX; } void SetParams () { popSize = (int)params [0].val; cohesionWeight = params [1].val; cohesionDist = params [2].val; separationWeight = params [3].val; separationDist = params [4].val; alignmentWeight = params [5].val; alignmentDist = params [6].val; maxSpeed = params [7].val; minSpeed = params [8].val; learningRate = params [9].val; neuralInfluence = params [10].val; explorationRate = params [11].val; } bool Init (const double &rangeMinP [], const double &rangeMaxP [], const double &rangeStepP [], const int epochsP = 0); void Moving (); void Revision (); //---------------------------------------------------------------------------- double cohesionWeight; // вес сближения double cohesionDist; // дистанция сближения double separationWeight; // вес разделения double separationDist; // дистанция разделения double alignmentWeight; // вес выравнивания double alignmentDist; // дистанция выравнивания double minSpeed; // минимальная скорость double maxSpeed; // максимальная скорость double learningRate; // скорость обучения нейронной сети double neuralInfluence; // влияние нейронной сети на движение double explorationRate; // вероятность случайного исследования int m_stagnationCounter; // счетчик стагнации double m_prevBestFitness; // предыдущее лучшее значение фитнеса S_NeuroBoids_Agent agent []; // агенты (боиды) private: //------------------------------------------------------------------- double distanceMax; // максимальная дистанция double speedMax []; // максимальные скорости по измерениям int neuron_size; // размер нейрона (количество входов) void CalculateMass (); // расчет масс агентов void Cohesion (S_NeuroBoids_Agent &boid, int pos); // правило сближения void Separation (S_NeuroBoids_Agent &boid, int pos); // правило разделения void Alignment (S_NeuroBoids_Agent &boid, int pos); // правило выравнивания void LimitSpeed (S_NeuroBoids_Agent &boid); // ограничение скорости void KeepWithinBounds (S_NeuroBoids_Agent &boid); // удержание в границах double Distance (S_NeuroBoids_Agent &boid1, S_NeuroBoids_Agent &boid2); // расчет дистанции void ApplyNeuralControl (S_NeuroBoids_Agent &boid, int pos); // применение нейронного управления void AdaptiveExploration (); // адаптивное исследование }; //——————————————————————————————————————————————————————————————————————————————
Метод "Init" отвечает за инициализацию параметров алгоритма и агентов и начинает свою работу с вызова "StandardInit", передавая ему массивы минимальных и максимальных значений диапазона и шагов поиска. Если стандартная инициализация не удается, метод сразу возвращает "false". Устанавливается размер нейрона, который будет использоваться в нейронной сети агентов.
В данном случае, размер рассчитывается как количество координат, умноженное на 2, а также добавляются два дополнительных значения: "dist_to_best" и "current_fitness". Происходит изменение размера массива агентов, в соответствии с заданным размером популяции "popSize". Затем, для каждого агента вызывается метод "Init ", который инициализирует его параметры, в том числе, нейронную сеть.
Расчет максимального расстояния и скорости:
- Переменная "distanceMax" инициализируется нулем.
- Для каждой координаты рассчитывается максимальное значение скорости, основываясь на разнице между максимальным и минимальным значениями диапазона.
- Также вычисляется максимальное расстояние, как квадратный корень из суммы квадратов максимальных скоростей.
Счетчик стагнации (m_stagnationCounter) сбрасывается в ноль, а переменная хранения предыдущего лучшего значения фитнеса (m_prevBestFitness) устанавливается в минимально возможное значение. Метод устанавливает различные глобальные переменные, такие как веса сближения, разделения и выравнивания, максимальные и минимальные скорости, скорость обучения, влияние нейронной сети и вероятность исследования. Если все этапы прошли успешно, метод возвращает "true", что подтверждает успешную инициализацию.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_NOA2::Init (const double &rangeMinP [], // минимальный диапазон поиска const double &rangeMaxP [], // максимальный диапазон поиска const double &rangeStepP [], // шаг поиска const int epochsP) // количество эпох { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; //---------------------------------------------------------------------------- // Определение размера нейрона neuron_size = coords * 2 + 2; // x, dx, dist_to_best, current_fitness // Инициализация агентов ArrayResize (agent, popSize); for (int i = 0; i < popSize; i++) { agent [i].Init (coords, neuron_size); } distanceMax = 0; ArrayResize (speedMax, coords); for (int c = 0; c < coords; c++) { speedMax [c] = rangeMax [c] - rangeMin [c]; distanceMax += MathPow (speedMax [c], 2); } distanceMax = MathSqrt (distanceMax); // Сброс счетчика стагнации и предыдущего лучшего значения фитнеса m_stagnationCounter = 0; m_prevBestFitness = -DBL_MAX; GlobalVariableSet ("#reset", 1.0); GlobalVariableSet ("1cohesionWeight", params [1].val); GlobalVariableSet ("2cohesionDist", params [2].val); GlobalVariableSet ("3separationWeight", params [3].val); GlobalVariableSet ("4separationDist", params [4].val); GlobalVariableSet ("5alignmentWeight", params [5].val); GlobalVariableSet ("6alignmentDist", params [6].val); GlobalVariableSet ("7maxSpeed", params [7].val); GlobalVariableSet ("8minSpeed", params [8].val); GlobalVariableSet ("9learningRate", params [9].val); GlobalVariableSet ("10neuralInfluence", params [10].val); GlobalVariableSet ("11explorationRate", params [11].val); return true; } //——————————————————————————————————————————————————————————————————————————————
Метод "Moving" отвечает за перемещение агентов в среде, основываясь на полученных данных и взаимодействии между ними. Сначала метод проверяет значение глобальной переменной "#reset", если она равна 1.0, происходит сброс параметров (переменная "revision" устанавливается в "false", а затем возвращается к "0.0"). Из глобальных переменных извлекаются значения различных параметров, таких как веса сближения, разделения и выравнивания, минимальная и максимальная скорости, скорость обучения, влияние нейронной сети и коэффициент исследования. Эти параметры могут быть настроены для изменения поведения агентов.
Если переменная "revision" равна "false", происходит инициализация позиций "x" и скоростей "dx" агентов. Для каждой координаты применяются случайные значения из заданного диапазона, а скорости устанавливаются на малые случайные значения. В каждой координате также сохраняется состояние агента, основанное на его текущей позиции. Метод "AdaptiveExploration ()" вызывается для адаптивного поиска, который может изменять поведение агентов в зависимости от состояния стагнации.
Основной цикл движения агентов (для каждого):
- Запоминается текущий опыт агента.
- Обновляется лучшая позиция, которую агент нашел.
- Обновляются входные данные нейронной сети агента.
- Выполняется прямое распространение данных через нейронную сеть.
- Агенты обучаются на основе накопленного опыта.
Применение правил и движение: вновь начинается цикл по агентам, для каждого применяются стандартные правила алгоритма боидов:
- Сближение (Cohesion): агенты стремятся быть ближе друг к другу.
- Разделение (Separation): агенты избегают сближения друг с другом, чтобы не сталкиваться.
- Выравнивание (Alignment): агенты стараются двигаться в одном направлении со своими соседями.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_NOA2::Moving () { double reset = GlobalVariableGet ("#reset"); if (reset == 1.0) { revision = false; GlobalVariableSet ("#reset", 0.0); } // Получение параметров из глобальных переменных для интерактивной настройки cohesionWeight = GlobalVariableGet ("1cohesionWeight"); cohesionDist = GlobalVariableGet ("2cohesionDist"); separationWeight = GlobalVariableGet ("3separationWeight"); separationDist = GlobalVariableGet ("4separationDist"); alignmentWeight = GlobalVariableGet ("5alignmentWeight"); alignmentDist = GlobalVariableGet ("6alignmentDist"); maxSpeed = GlobalVariableGet ("7maxSpeed"); minSpeed = GlobalVariableGet ("8minSpeed"); learningRate = GlobalVariableGet ("9learningRate"); neuralInfluence = GlobalVariableGet ("10neuralInfluence"); explorationRate = GlobalVariableGet ("11explorationRate"); // Инициализация начальных позиций и скоростей if (!revision) { for (int i = 0; i < popSize; i++) { for (int c = 0; c < coords; c++) { agent [i].x [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); agent [i].dx [c] = (rangeMax [c] - rangeMin [c]) * u.RNDfromCI (-1.0, 1.0) * 0.001; a [i].c [c] = u.SeInDiSp (agent [i].x [c], rangeMin [c], rangeMax [c], rangeStep [c]); } } revision = true; return; } // Адаптивное исследование в зависимости от стагнации AdaptiveExploration (); //---------------------------------------------------------------------------- // Основной цикл движения боидов for (int i = 0; i < popSize; i++) { // Запоминаем текущий опыт agent [i].MemorizeExperience (a [i].f, coords); // Обновляем лучшую позицию агента agent [i].UpdateBestPosition (a [i].f, coords); // Обновляем входы нейронной сети agent [i].UpdateInputs (cB, a [i].f, coords); // Прямое распространение по нейронной сети agent [i].ForwardPass (coords); // Обучение на основе накопленного опыта agent [i].Learn (learningRate, coords); } // Расчет масс CalculateMass (); // Применение правил и движение for (int i = 0; i < popSize; i++) { // Стандартные правила алгоритма боидов Cohesion (agent [i], i); Separation (agent [i], i); Alignment (agent [i], i); // Применение нейронного управления ApplyNeuralControl (agent [i], i); // Ограничение скорости и удержание в границах LimitSpeed (agent [i]); KeepWithinBounds (agent [i]); // Обновление позиций for (int c = 0; c < coords; c++) { agent [i].x [c] += agent [i].dx [c]; a [i].c [c] = u.SeInDiSp (agent [i].x [c], rangeMin [c], rangeMax [c], rangeStep [c]); } } } //——————————————————————————————————————————————————————————————————————————————
Метод "CalculateMass" выполняет вычисление "массы" агентов на основе их фитнеса (продуктивности) и нормализует эти значения. Переменные "maxMass" и "minMass" инициализируются значениями -DBL_MAX и DBL_MAX соответственно. Эти переменные будут использоваться для нахождения наибольшего и наименьшего значений фитнеса среди всего населения агентов. Метод проверяет, имеется ли хотя бы один агент, проверяя, что "popSize" (размер популяции) больше нуля. Если агентов нет, метод завершает выполнение. В первом цикле перебираются все агенты (от 0 до popSize), и для каждого проверяется, является ли его фитнес (значение a[i].f) больше текущего "maxMass" или меньше "minMass".
В результате этого цикла будут определены максимальное и минимальное значения фитнеса среди всех агентов. Во втором цикле снова перебираются все агенты, и для каждого рассчитывается его "масса" (переменная "m") с помощью функции "u.Scale", которая нормализует фитнес-значения.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_NOA2::CalculateMass () { double maxMass = -DBL_MAX; double minMass = DBL_MAX; // Проверка на наличие данных перед вычислениями if (popSize <= 0) return; for (int i = 0; i < popSize; i++) { if (a [i].f > maxMass) maxMass = a [i].f; if (a [i].f < minMass) minMass = a [i].f; } for (int i = 0; i < popSize; i++) { agent [i].m = u.Scale (a [i].f, minMass, maxMass, 0.1, 1.0); } } //——————————————————————————————————————————————————————————————————————————————
Метод "ApplyNeuralControl" отвечает за применение управления, основанного на выходах нейронной сети, к агенту типа "боид". Метод перебирает все координаты агента "coords". Для каждой координаты "c" проверяется, что текущий индекс не выходит за границы массива выходов "boid.outputs". Если индекс корректен, производится коррекция скорости "dx[c]" агента на основе соответствующего значения из выходов нейронной сети, умноженного на ее влияние "neuralInfluence".
Извлекается размер массива "boid.outputs" для упрощения дальнейших проверок. Для коэффициентов сближения, разделения и выравнивания "cohesion_factor", "separation_factor", "alignment_factor" проверяется, находятся ли соответствующие индексы в пределах массива выходов. Если индекс выходит за границы, присваивается значение по умолчанию 0.5. Эти коэффициенты используются для масштабирования базовых весов с учетом воздействия нейронной сети. Они влияют на поведение агентов, изменяя веса для сближения, разделения и выравнивания:
- local_cohesion устанавливает вес сближения.
- local_separation устанавливает вес разделения.
- local_alignment устанавливает вес выравнивания.
Метод проверяет, нужно ли провести случайное исследование, используя заданную вероятность "xplorationRate", если условие выполняется, выбирается случайная координата "c" для возмущения. Размер возмущения "perturbation_size" вычисляется на основе массы агента (которое является мерой его фитнеса) и диапазона возможных значений для этой координаты. Это позволяет контролировать величину случайного изменения, несмотря на массу агента. К скорости "dx[c]" добавляется случайное возмущение, выбираемое из диапазона от "perturbation_size" до "perturbation_size". Метод "ApplyNeuralControl" осуществляет интеграцию результатов работы нейронной сети в процесс управления движением агентов. Он корректирует их скорость на основе данных, метод также учитывает необходимость случайного исследования.
//—————————————————————————————————————————————————————————————————————————————— // Применение нейронного управления к боиду void C_AO_NOA2::ApplyNeuralControl (S_NeuroBoids_Agent &boid, int pos) { // Используем выходы нейронной сети для коррекции скорости for (int c = 0; c < coords; c++) { // Проверяем, что индекс не выходит за границы массива if (c < ArraySize (boid.outputs)) { // Применяем нейронную коррекцию скорости с заданным влиянием boid.dx [c] += boid.outputs [c] * neuralInfluence; } } // Используем выходы нейронной сети для адаптации параметров стаи // Проверяем, что индексы не выходят за границы массива int output_size = ArraySize (boid.outputs); double cohesion_factor = (coords < output_size) ? boid.outputs [coords] : 0.5; double separation_factor = (coords + 1 < output_size) ? boid.outputs [coords + 1] : 0.5; double alignment_factor = (coords + 2 < output_size) ? boid.outputs [coords + 2] : 0.5; // Масштабируем базовые веса с учетом нейронной адаптации // Эти переменные локальные и не изменяют глобальные параметры double local_cohesion = cohesionWeight * (0.5 + cohesion_factor); double local_separation = separationWeight * (0.5 + separation_factor); double local_alignment = alignmentWeight * (0.5 + alignment_factor); // Случайное исследование с заданной вероятностью if (u.RNDprobab () < explorationRate) { // Выбираем случайную координату для возмущения int c = (int)u.RNDfromCI (0, coords - 1); // Адаптивный размер возмущения в зависимости от массы (фитнеса) double perturbation_size = (1.0 - boid.m) * (rangeMax [c] - rangeMin [c]) * 0.01; // Добавляем случайное возмущение boid.dx [c] += u.RNDfromCI (-perturbation_size, perturbation_size); } } //——————————————————————————————————————————————————————————————————————————————
Метод "AdaptiveExploration" класса "C_AO_NOA2" реализует адаптивное исследование в зависимости от стадии стагнации в процессе оптимизации. Метод начинает с проверки, изменилось ли значение целевой функции "fB" по сравнению с предыдущим лучшим значением "m_prevBestFitness". Если разница между ними меньше чем 0.000001, считается, что нет прогресса, и увеличивается счетчик стагнации "m_stagnationCounter". В противном случае, стагнация прекращается, счетчик сбрасывается, и текущее значение "fB" сохраняется как новое лучшее.
Если количество стагнации превышает 20, увеличивается вероятность случайного исследования "explorationRate", но она ограничивается значением "0.5" для предотвращения слишком высокой вероятности случайных изменений. Каждые 50 итераций стагнации происходит частичный рестарт: 70% агентов в популяции перезапускаются с новыми случайными значениями в пределах заданных диапазонов "rangeMin" и "rangeMax". При этом оставшиеся лучшие агенты с их текущими позициями остаются неизменными. После перезапуска счетчик стагнации сбрасывается.
Если прогресс есть, и количество параметров "params" больше 11, устанавливается вероятность исследования "explorationRate" из массива параметров. Если параметров меньше, устанавливается значение по умолчанию, равное 0.1.
//—————————————————————————————————————————————————————————————————————————————— // Адаптивное исследование в зависимости от стагнации void C_AO_NOA2::AdaptiveExploration () { // Определяем, есть ли прогресс в поиске if (MathAbs (fB - m_prevBestFitness) < 0.000001) { m_stagnationCounter++; } else { m_stagnationCounter = 0; m_prevBestFitness = fB; } // Увеличиваем исследование при стагнации if (m_stagnationCounter > 20) { // Увеличиваем вероятность случайного исследования explorationRate = MathMin (0.5, explorationRate * 1.5); // Каждые 50 итераций стагнации выполняем частичный рестарт if (m_stagnationCounter % 50 == 0) { // Перезапускаем 70% популяции, оставляя лучших агентов int restart_count = (int)(popSize * 0.7); for (int i = popSize - restart_count; i < popSize; i++) { for (int c = 0; c < coords; c++) { agent [i].x [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); agent [i].dx [c] = (rangeMax [c] - rangeMin [c]) * u.RNDfromCI (-1.0, 1.0) * 0.001; } } // Сбрасываем счетчик стагнации m_stagnationCounter = 0; } } else { // При хорошем прогрессе используем обычный уровень исследования if (11 < ArraySize (params)) { explorationRate = params [11].val; } else { explorationRate = 0.1; // значение по умолчанию } } } //——————————————————————————————————————————————————————————————————————————————
Метод "Cohesion" класса "C_AO_NOA2" отвечает за реализацию поведения схождения "cohesion" для агентной модели боидов. Объявление переменных:
- centerX — массив будет использоваться для хранения координат центра масс соседних агентов. Размер массива соответствует количеству координат "coords".
- numNeighbors — счетчик соседей будет отслеживать количество агентов, находящихся в пределах заданного расстояния (с учетом массы).
- sumMass — сумма масс соседних агентов будет использоваться для нормализации координат центра масс.
Первый цикл (от 0 до popSize) суммирует массы всех агентов в популяции, исключая текущего боида (агента) по индексу "pos". Второй цикл проходит через всех агентов и проверяет, находятся ли они в пределах максимального расстояния, умноженного на коэффициент "cohesionDist" от текущего боида. Если расстояние до агента меньше указанного максимума, координаты данного агента (с учетом его массы) добавляются к "centerX", а также увеличивается счетчик "numNeighbors".
После того, как были вычислены суммы координат и масса соседей, проверяется, есть ли соседи (т.е. numNeighbors > 0) и сумма масс (sumMass > 0.0), и если соседи найдены, координаты центра масс нормализуются (путем деления на сумму масс). Затем текущая скорость "dx" боида увеличивается в направлении центра масс с заданным весом "cohesionWeight", это означает, что боид будет двигаться к центру масс своих соседей, учитывая их массы.
Метод "Cohesion" рассчитывает центр масс и корректирует скорость текущего боида таким образом, чтобы он "сходился" к этому центру. Это поведение является одним из ключевых аспектов симуляции поведения стаи или группы. Параметры, такие как "cohesionDist" и "cohesionWeight", позволяют управлять расстоянием, на котором действует это поведение, и степенью влияния центра масс на передвижение боидов.
//—————————————————————————————————————————————————————————————————————————————— // Найти центр масс других боидов и скорректировать скорость в направлении центра масс void C_AO_NOA2::Cohesion (S_NeuroBoids_Agent &boid, int pos) { double centerX []; ArrayResize (centerX, coords); ArrayInitialize (centerX, 0.0); int numNeighbors = 0; double sumMass = 0; for (int i = 0; i < popSize; i++) { if (pos != i) sumMass += agent [i].m; } for (int i = 0; i < popSize; i++) { if (pos != i) { if (Distance (boid, agent [i]) < distanceMax * cohesionDist) { for (int c = 0; c < coords; c++) { centerX [c] += agent [i].x [c] * agent [i].m; } numNeighbors++; } } } if (numNeighbors > 0 && sumMass > 0.0) { for (int c = 0; c < coords; c++) { centerX [c] /= sumMass; boid.dx [c] += (centerX [c] - boid.x [c]) * cohesionWeight; } } } //——————————————————————————————————————————————————————————————————————————————
Метод "Separation" класса "C_AO_NOA2" реализует поведение отталкивания (separation) для агентов модели, которое предназначено для предотвращения столкновений между боидом и соседними агентами, "moveX" — параметры, такие как "cohesionDist" массив будет использоваться для хранения векторов смещения, чтобы оттолкнуть боид от других агентов.
Размер массива соответствует количеству координат "coords". Массив "moveX" инициализируется нулями, чтобы избежать накопления случайных значений, далее происходит перебор всех агентов в популяции (от 0 до popSize). Затем проверяется, близок ли агент к текущему боиду. Это делается с помощью функции "Distance", и если расстояние между боидом и агентом меньше заданного максимума (умноженного на коэффициент "separationDist"), то для каждой координаты выполняется вычитание координат агента из координат текущего боида, чтобы эффективно создать вектор, указывающий в сторону текущего боида (то есть отталкивать от агента).
После завершения цикла по агентам, текущая скорость "dx" боида увеличивается на рассчитанный вектор смещения "moveX", умноженный на коэффициент "separationWeight". Это позволяет контролировать силу отталкивания: чем больше значение "separationWeight", тем сильнее боид будет избегать столкновений.
Метод "Separation" реализует поведение, которое заставляет боид отталкиваться от ближайших соседей, предотвращая столкновения. Это важный аспект в моделировании поведения стаи, который помогает поддерживать личное пространство для каждого агента и способствует более естественному взаимодействию между ними. Параметры, такие как "separationDist" и "separationWeight", позволяют гибко настраивать радиус действия и силу эффекта отталкивания, соответственно.
//—————————————————————————————————————————————————————————————————————————————— // Отталкивание от других боидов, чтобы избежать столкновений void C_AO_NOA2::Separation (S_NeuroBoids_Agent &boid, int pos) { double moveX []; ArrayResize (moveX, coords); ArrayInitialize (moveX, 0.0); for (int i = 0; i < popSize; i++) { if (pos != i) { if (Distance (boid, agent [i]) < distanceMax * separationDist) { for (int c = 0; c < coords; c++) { moveX [c] += boid.x [c] - agent [i].x [c]; } } } } for (int c = 0; c < coords; c++) { boid.dx [c] += moveX [c] * separationWeight; } } //——————————————————————————————————————————————————————————————————————————————
Метод "Alignment" класса "C_AO_NOA2" реализует поведение выравнивания (alignment) для агентов в модели. Это поведение заставляет боидов согласовывать свои скорости с соседними агентами, чтобы создать более гармоничное и координированное движение группы, "avgDX" — массив, который будет использоваться для хранения среднего вектора скорости соседних агентов. Размер массива соответствует количеству координат "coords", "numNeighbors" — счетчик, который отслеживает количество соседей, оказавшихся в пределах заданного расстояния.
Цикл проходит через всех агентов в популяции. Внутри цикла проверяется, не является ли текущий агент тем самым боидом. Если расстояние до другого агента меньше заданного максимума, умноженного на коэффициент "alignmentDist", текущая скорость "dx" этого агента добавляется к "avgDX". Счетчик "numNeighbors" увеличивается на 1. После завершения цикла, если были найдены соседи (т.е. numNeighbors > 0), то средняя скорость (avgDX) вычисляется путём деления суммированного вектора скоростей на количество соседей. Затем текущая скорость "dx" боида корректируется в сторону средней скорости соседей с учетом коэффициента "alignmentWeight".
Метод "Alignment" позволяет боиду адаптировать свою скорость в соответствии со скоростями своих соседей. Это поведение помогает группам боидов двигаться более согласованно и снижает вероятность конфликтов или резких изменений направления. Параметры, такие как "alignmentDist" и "alignmentWeight", задают радиус действия эффекта выравнивания и степень влияния средней скорости соседей на скорость текущего боида соответственно.//—————————————————————————————————————————————————————————————————————————————— // Выравнивание скорости с другими боидами void C_AO_NOA2::Alignment (S_NeuroBoids_Agent &boid, int pos) { double avgDX []; ArrayResize (avgDX, coords); ArrayInitialize (avgDX, 0.0); int numNeighbors = 0; for (int i = 0; i < popSize; i++) { if (pos != i) { if (Distance (boid, agent [i]) < distanceMax * alignmentDist) { for (int c = 0; c < coords; c++) { avgDX [c] += agent [i].dx [c]; } numNeighbors++; } } } if (numNeighbors > 0) { for (int c = 0; c < coords; c++) { avgDX [c] /= numNeighbors; boid.dx [c] += (avgDX [c] - boid.dx [c]) * alignmentWeight; } } } //——————————————————————————————————————————————————————————————————————————————
Метод "LimitSpeed" класса "C_AO_NOA2" предназначен для контроля скорости агентов (боидов) в модели, чтобы убедиться, что скорости боидов находятся в заданном диапазоне, "speed" - переменная для хранения текущей скорости боидов, которая будет вычисляться как длина вектора скорости. Цикл по координатам (coords) вычисляет квадрат скорости для каждой координаты (добавляя boid.dx [c] * boid.dx [c]) и суммирует их. Это позволяет вычислить квадрат длины вектора скорости. Затем длина (или фактическая скорость) достигается с помощью функции "MathSqrt", которая вычисляет квадратный корень из суммы квадратов. Если скорость больше небольшого значения (1e-10), программа продолжает выполнение, если текущая скорость меньше минимальной допустимой скорости (определяемой как speedMax[0] * minSpeed), тогда вектор скорости "boid.dx" нормализуется (делится на его текущую длину) и увеличивается до величины, равной минимальной допустимого значения.
Если текущая скорость больше максимальной допустимой скорости (speedMax[0] * maxSpeed), тогда аналогично, вектор скорости нормализуется и устанавливается на величину максимальной скорости, а если скорость почти нулевая (ноль или очень близко к нулю), в этом случае, каждая координата вектора скорости замещается на небольшое случайное значение, полученное с помощью функции "u.RNDfromCI (-1.0, 1.0)", умноженное на максимальную скорость.
Метод "LimitSpeed" обеспечивает поддержание скорости боидов в допустимых пределах, предотвращая слишком медленные или слишком быстрые движения. Это поведение позволяет создать более реалистичное моделирование агентов, так как оно не допускает значительных отклонений в скорости, что может привести к неестественному движению. Параметры "minSpeed" и "maxSpeed" могут быть настроены для регулировки поведения агентов и их скорости в зависимости от задач моделирования.
//—————————————————————————————————————————————————————————————————————————————— // Ограничение скорости void C_AO_NOA2::LimitSpeed (S_NeuroBoids_Agent &boid) { double speed = 0; for (int c = 0; c < coords; c++) { speed += boid.dx [c] * boid.dx [c]; } speed = MathSqrt (speed); // Если скорость не нулевая (предотвращаем деление на ноль) if (speed > 1e-10) { // Если скорость слишком мала, увеличиваем её if (speed < speedMax [0] * minSpeed) { for (int c = 0; c < coords; c++) { boid.dx [c] = boid.dx [c] / speed * speedMax [c] * minSpeed; } } // Если скорость слишком велика, уменьшаем её else if (speed > speedMax [0] * maxSpeed) { for (int c = 0; c < coords; c++) { boid.dx [c] = boid.dx [c] / speed * speedMax [c] * maxSpeed; } } } else { // Если скорость почти нулевая, задаем небольшую случайную скорость for (int c = 0; c < coords; c++) { boid.dx [c] = u.RNDfromCI (-1.0, 1.0) * speedMax [c] * minSpeed; } } } //——————————————————————————————————————————————————————————————————————————————
Метод "KeepWithinBounds" класса "C_AO_NOA2" предназначен для удержания агента (боидa) в заданных границах. Если боид оказывается слишком близко к краям области, этот метод изменяет его направление и обеспечивает определённый толчок обратно в границы. Метод начинается с цикла по всем координатам, что позволяет работать с многомерным пространством.
Для каждой координаты проверяет, находится ли позиция боидa (boid.x [c]) ниже минимальной границы (rangeMin[c]), если да, то направление скорости (boid.dx[c]) инвертируется с помощью "boid.dx [c] *= -1.0". Это означает, что боид будет двигаться в противоположном направлении. Затем добавляется небольшой толчок от границы: (rangeMax[c] - rangeMin[c]) * 0.001, который помогает выталкивать боид обратно внутрь области.
Выполняется аналогичная проверка для максимальной границы (rangeMax[c]): если позиция боида выходит за рамки максимума, его скорость также инвертируется и корректируется, но с вычитанием некоторого значения, аналогичного предыдущему случаю.
Метод "KeepWithinBounds" эффективно ограничивает движения боидов в заданной области, предотвращая вылет за пределы и обеспечивая их возвращение внутрь.
//—————————————————————————————————————————————————————————————————————————————— // Удержание боида в границах. Если он оказывается слишком близко к краю, // подталкиваем его обратно и меняем направление. void C_AO_NOA2::KeepWithinBounds (S_NeuroBoids_Agent &boid) { for (int c = 0; c < coords; c++) { if (boid.x [c] < rangeMin [c]) { boid.dx [c] *= -1.0; // Добавляем небольшой толчок от границы boid.dx [c] += (rangeMax [c] - rangeMin [c]) * 0.001; } if (boid.x [c] > rangeMax [c]) { boid.dx [c] *= -1.0; // Добавляем небольшой толчок от границы boid.dx [c] -= (rangeMax [c] - rangeMin [c]) * 0.001; } } } //——————————————————————————————————————————————————————————————————————————————
Метод "Distance" класса "C_AO_NOA2" предназначен для вычисления расстояния между двумя агентами (боидами) в многомерном пространстве. Он использует формулу для вычисления евклидова расстояния, "dist" — переменная, в которой будет храниться сумма квадратов разностей координат двух боидов.
Метод запускает цикл, который проходит по всем координатам, что позволяет вычислять расстояние в пространстве любой размерности. Для каждой координаты "c" вычисляется квадрат разности между соответствующими координатами обоих боидов: boid1.x[c] - boid2.x[c].
Результаты ((boid1.x[c] - boid2.x[c])^2) добавляются к переменной "dist". После завершения цикла, переменная "dist" будет содержать сумму квадратов разностей координат. Для получения фактического расстояния, метод использует "MathSqrt", чтобы вычислить квадратный корень из суммы квадратов, что соответствует формуле евклидова расстояния.
//—————————————————————————————————————————————————————————————————————————————— // Расчет расстояния между двумя боидами double C_AO_NOA2::Distance (S_NeuroBoids_Agent &boid1, S_NeuroBoids_Agent &boid2) { double dist = 0; for (int c = 0; c < coords; c++) { dist += MathPow (boid1.x [c] - boid2.x [c], 2); } return MathSqrt (dist); } //——————————————————————————————————————————————————————————————————————————————
Метод "Revision" класса "C_AO_NOA2" отвечает за обновление информации о наилучшем найденном решении в процессе оптимизации. Этот процесс включает в себя обновление значения фитнес-функции, а также координат, соответствующих этому значению. Метод также отслеживает прогресс и адаптирует параметры алгоритма, если есть существенные улучшения. Метод проходит по всей популяции, представленной массивом "a", который содержит "popSize" (число агентов).
Внутри цикла происходит проверка каждого агента на то, является ли его фитнес-значение (a[i].f) больше, чем текущее лучшее значение (fB). Если текущий агент показывает лучшее фитнес-значение, — обновляется глобальное лучшее значение фитнес-функции, присваивая "fB" новое значение "a[i].f", далее происходит обновление координат лучшего решения. Для каждой координаты "c" массив "cB" (содержащий координаты лучшего решения) обновляется значениями текущего агента. Счетчик стагнации (m_stagnationCounter) сбрасывается до нуля, потому что было найдено улучшение в решении.
Метод использует переменную "hasProgress", чтобы определить, был ли достигнут прогресс. Это делается путем вычисления абсолютной разности между текущим и предыдущим лучшими значениями фитнес-функции (MathAbs(fB - m_prevBestFitness)), и если эта разность больше 0.000001, считается, что прогресс налицо. Если прогресс есть, обновляется "m_prevBestFitness" на текущее лучшее значение "fB".
Также происходит адаптация скорости исследования "explorationRate": она уменьшается, если найдено улучшение, с учетом некоторого параметра из массива "params" и текущего значения "explorationRate".
//—————————————————————————————————————————————————————————————————————————————— // Обновление лучшего найденного решения void C_AO_NOA2::Revision () { // Обновляем лучшие координаты и значение фитнес-функции for (int i = 0; i < popSize; i++) { // Обновление глобального лучшего решения if (a [i].f > fB) { fB = a [i].f; for (int c = 0; c < coords; c++) { cB [c] = a [i].c [c]; } // Сбрасываем счетчик стагнации при нахождении лучшего решения m_stagnationCounter = 0; } } // Проверка наличия прогресса для адаптации параметров алгоритма bool hasProgress = MathAbs (fB - m_prevBestFitness) > 0.000001; if (hasProgress) { m_prevBestFitness = fB; explorationRate = MathMax (params [11].val * 0.5, explorationRate * 0.9); } } //——————————————————————————————————————————————————————————————————————————————
Результаты тестов
Результаты тестирования достаточно слабые.NOA2|Neuroboids Optimization Algorithm 2 (joo)|50.0|0.6|0.001|0.005|0.03|0.1|0.1|0.1|0.01|0.01|0.3|0.1|
=============================
5 Hilly's; Func runs: 10000; result: 0.47680799582735267
25 Hilly's; Func runs: 10000; result: 0.30763714006051013
500 Hilly's; Func runs: 10000; result: 0.2544737238936433
=============================
5 Forest's; Func runs: 10000; result: 0.3238017030688524
25 Forest's; Func runs: 10000; result: 0.20976876473929068
500 Forest's; Func runs: 10000; result: 0.15740101965732595
=============================
5 Megacity's; Func runs: 10000; result: 0.27076923076923076
25 Megacity's; Func runs: 10000; result: 0.14676923076923082
500 Megacity's; Func runs: 10000; result: 0.09729230769230844
=============================
All score: 2.24472 (24.94%)
На визуализации можно заметить скромные возможности поиска. Возможность изменения внешних параметров алгоритма с помощью глобальных переменных позволяет эксперементировать с поведением боидов, выявляя интересные модели поведения. Ниже представлены визуализации одних из множества возможных моделей поведения.
NOA2 на тестовой функции Hilly
NOA2 на тестовой функции Forest
NOA2 на тестовой функции Megacity
По итогам тестирования, алгоритм NOA2 в базовой версии только в ознакомительных целях приводится в нашей рейтинговой таблице популяционных алгоритмов оптимизации.
| № | 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 (joo) | 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 (joo) | 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 | TETA | time evolution travel algorithm (joo) | 0,91362 | 0,82349 | 0,31990 | 2,05701 | 0,97096 | 0,89532 | 0,29324 | 2,15952 | 0,73462 | 0,68569 | 0,16021 | 1,58052 | 5,797 | 64,41 |
| 7 | 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 |
| 8 | BOAm | billiards optimization algorithm M | 0,95757 | 0,82599 | 0,25235 | 2,03590 | 1,00000 | 0,90036 | 0,30502 | 2,20538 | 0,73538 | 0,52523 | 0,09563 | 1,35625 | 5,598 | 62,19 |
| 9 | 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 |
| 10 | ESG | evolution of social groups (joo) | 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 |
| 11 | SIA | simulated isotropic annealing (joo) | 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 |
| 12 | 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 |
| 13 | DA | dialectical algorithm | 0,86183 | 0,70033 | 0,33724 | 1,89940 | 0,98163 | 0,72772 | 0,28718 | 1,99653 | 0,70308 | 0,45292 | 0,16367 | 1,31967 | 5,216 | 57,95 |
| 14 | BHAm | black hole algorithm M | 0,75236 | 0,76675 | 0,34583 | 1,86493 | 0,93593 | 0,80152 | 0,27177 | 2,00923 | 0,65077 | 0,51646 | 0,15472 | 1,32195 | 5,196 | 57,73 |
| 15 | 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 |
| 16 | RFO | royal flush optimization (joo) | 0,83361 | 0,73742 | 0,34629 | 1,91733 | 0,89424 | 0,73824 | 0,24098 | 1,87346 | 0,63154 | 0,50292 | 0,16421 | 1,29867 | 5,089 | 56,55 |
| 17 | AOSm | atomic orbital search M | 0,80232 | 0,70449 | 0,31021 | 1,81702 | 0,85660 | 0,69451 | 0,21996 | 1,77107 | 0,74615 | 0,52862 | 0,14358 | 1,41835 | 5,006 | 55,63 |
| 18 | TSEA | turtle shell evolution algorithm (joo) | 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 |
| 19 | 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 |
| 20 | SRA | successful restaurateur algorithm (joo) | 0,96883 | 0,63455 | 0,29217 | 1,89555 | 0,94637 | 0,55506 | 0,19124 | 1,69267 | 0,74923 | 0,44031 | 0,12526 | 1,31480 | 4,903 | 54,48 |
| 21 | 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 |
| 22 | BIO | blood inheritance optimization (joo) | 0,81568 | 0,65336 | 0,30877 | 1,77781 | 0,89937 | 0,65319 | 0,21760 | 1,77016 | 0,67846 | 0,47631 | 0,13902 | 1,29378 | 4,842 | 53,80 |
| 23 | 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 |
| 24 | 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 |
| 25 | 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 |
| 26 | 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 |
| 27 | ABO | african buffalo optimization | 0,83337 | 0,62247 | 0,29964 | 1,75548 | 0,92170 | 0,58618 | 0,19723 | 1,70511 | 0,61000 | 0,43154 | 0,13225 | 1,17378 | 4,634 | 51,49 |
| 28 | (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 |
| 29 | 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 |
| 30 | 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 |
| 31 | 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 |
| 32 | 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 |
| 33 | AEO | artificial ecosystem-based optimization algorithm | 0,91380 | 0,46713 | 0,26470 | 1,64563 | 0,90223 | 0,43705 | 0,21400 | 1,55327 | 0,66154 | 0,30800 | 0,28563 | 1,25517 | 4,454 | 49,49 |
| 34 | 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 |
| 35 | 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 |
| 36 | SOA | simple optimization algorithm | 0,91520 | 0,46976 | 0,27089 | 1,65585 | 0,89675 | 0,37401 | 0,16984 | 1,44060 | 0,69538 | 0,28031 | 0,10852 | 1,08422 | 4,181 | 46,45 |
| 37 | 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 |
| 38 | 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 |
| 39 | ADAMm | adaptive moment estimation M | 0,88635 | 0,44766 | 0,26613 | 1,60014 | 0,84497 | 0,38493 | 0,16889 | 1,39880 | 0,66154 | 0,27046 | 0,10594 | 1,03794 | 4,037 | 44,85 |
| 40 | CGO | chaos game optimization | 0,57256 | 0,37158 | 0,32018 | 1,26432 | 0,61176 | 0,61931 | 0,62161 | 1,85267 | 0,37538 | 0,21923 | 0,19028 | 0,78490 | 3,902 | 43,35 |
| 41 | ATAm | artificial tribe algorithm M | 0,71771 | 0,55304 | 0,25235 | 1,52310 | 0,82491 | 0,55904 | 0,20473 | 1,58867 | 0,44000 | 0,18615 | 0,09411 | 0,72026 | 3,832 | 42,58 |
| 42 | CFO | central force optimization | 0,60961 | 0,54958 | 0,27831 | 1,43750 | 0,63418 | 0,46833 | 0,22541 | 1,32792 | 0,57231 | 0,23477 | 0,09586 | 0,90294 | 3,668 | 40,76 |
| 43 | ASHA | artificial showering algorithm | 0,89686 | 0,40433 | 0,25617 | 1,55737 | 0,80360 | 0,35526 | 0,19160 | 1,35046 | 0,47692 | 0,18123 | 0,09774 | 0,75589 | 3,664 | 40,71 |
| 44 | 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 |
| 45 | 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 |
| NOA2 | neuroboids optimization algorithm 2(joo) | 0,47681 | 0,30764 | 0,25447 | 1,03892 | 0,32380 | 0,20977 | 0,15740 | 0,69097 | 0,27077 | 0,14677 | 0,09729 | 0,51483 | 2,245 | 24,94 | |
Выводы
Разработанный мной алгоритм нейробоидной оптимизации (NOA2) представляет собой гибридный подход, объединяющий принципы роевого интеллекта (алгоритм боидов) с нейронным управлением. Ключевая идея заключается в применении нейронной сети для адаптивного управления параметрами поведения агентов-боидов. В текущей реализации используется простая однослойная нейронная сеть без скрытых слоев. Она состоит из входного слоя, принимающего текущие координаты, скорости, расстояние до лучшего решения и значение фитнес-функции, а также выходного слоя, который определяет коррекцию скоростей и адаптивные параметры для правил поведения стаи боидов.
В данной версии отсутствуют промежуточные слои. Количество входов определяется как (coords * 2 + 2), где "coords" — это количество измерений пространства поиска. Выходы включают коррекцию по каждой координате и три дополнительных параметра для адаптации правил стаи. В алгоритме присутствует большое количество настраиваемых параметров, что утрудняет поиск наилучших и я перепробовал различные комбинации, но так и не нашел идеального сочетания, которое бы демонстрировало лучшие результаты на тестовых функциях.
В текущем виде, алгоритм явно служит демонстрацией концепции и в целом, является интересным экспериментом в области гибридных методов оптимизации, но не демонстрирует достаточной производительности для квалификации. Он набирает минимальное количество баллов в проведенных тестах и может рассматриваться лишь как иллюстрация подхода к гибридизации алгоритмов. Для заинтересованных исследователей и разработчиков код NOA2 может служить отправной точкой для экспериментов с различными конфигурациями и параметрами, а также для создания более совершенных гибридных алгоритмов оптимизации, использующих преимущества как популяционных методов, так и методов машинного обучения.
Рисунок 3. Цветовая градация алгоритмов по соответствующим тестам
Рисунок 4. Гистограмма результатов тестирования алгоритмов (по шкале от 0 до 100, чем больше, тем лучше, где 100 — максимально возможный теоретический результат, в архиве скрипт для расчета рейтинговой таблицы)
Плюсы и минусы алгоритма NOA2:
Плюсы:
- Интересная идея для реализации.
Минусы:
- Слабые результаты.
К статье прикреплён архив с актуальными версиями кодов алгоритмов. Автор статьи не несёт ответственности за абсолютную точность в описании канонических алгоритмов, во многие из них были внесены изменения для улучшения поисковых возможностей. Выводы и суждения, представленные в статьях, основываются на результатах проведённых экспериментов.
Программы, используемые в статье
| # | Имя | Тип | Описание |
|---|---|---|---|
| 1 | #C_AO.mqh | Включаемый файл | Родительский класс популяционных алгоритмов оптимизации |
| 2 | #C_AO_enum.mqh | Включаемый файл | Перечисление популяционных алгоритмов оптимизации |
| 3 | TestFunctions.mqh | Включаемый файл | Библиотека тестовых функций |
| 4 | TestStandFunctions.mqh | Включаемый файл | Библиотека функций тестового стенда |
| 5 | Utilities.mqh | Включаемый файл | Библиотека вспомогательных функций |
| 6 | CalculationTestResults.mqh | Включаемый файл | Скрипт для расчета результатов в сравнительную таблицу |
| 7 | Testing AOs.mq5 | Скрипт | Единый испытательный стенд для всех популяционных алгоритмов оптимизации |
| 8 | Simple use of population optimization algorithms.mq5 | Скрипт | Простой пример использования популяционных алгоритмов оптимизации без визуализации |
| 9 | Test_AO_NOA2.mq5 | Скрипт | Испытательный стенд для NOA2 |
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.
Создание торговой панели администратора на MQL5 (Часть II): Повышение оперативности реагирования и быстрого обмена сообщениями
Нейросети в трейдинге: Выявление аномалий в частотной области (Окончание)
Реализация модели таблицы в MQL5: Применение концепции MVC
Разработка трендовых торговых стратегий на основе машинного обучения
- Бесплатные приложения для трейдинга
- 8 000+ сигналов для копирования
- Экономические новости для анализа финансовых рынков
Вы принимаете политику сайта и условия использования