Алгоритм искусственной коронарной циркуляции — Artificial Coronary Circulation System (ACCS)
329
0
Содержание
Введение
Алгоритм Artificial Coronary Circulation System (ACCS) — это биовдохновлённый метаэвристический метод оптимизации. ACCS имитирует рост коронарных артерий в человеческом сердце. Идея заключается в том, что каждая артерия или капилляр представляет собой кандидатное решение, а весь процесс роста сосудистой системы — это аналог поиска оптимума в сложном пространстве решений. Алгоритм был предложен A. Kaveh и M. Kooshkbaghi в 2019г. в статье Artificial coronary circulation system: A new bio-inspired metaheuristic algorithm.
Реализация алгоритма
Представьте, что ваше сердце — не просто насос, это мудрый архитектор, который строит идеальные дороги для крови. Каждую секунду оно решает сложнейшую задачу: как доставить максимум кислорода, потратив минимум энергии. Ученые подсмотрели эту гениальную стратегию и решили создать на этой основе алгоритм ACCS.
В начале — хаос. Как в природе, когда капилляры только начинают прорастать, ACCS создаёт случайную популяцию решений. Капиллярный лидер (CL), который начинает искать путь к оптимальному решению, оценивается по фактору коронарного роста (CGF) — это как уровень энергии, показывающий, насколько хорошо он справляется с задачей. Каждый капилляр выбирает, как ему расти: поиск — он тянется вперёд, как корень, в надежде найти плодородную почву, разветвление — если условия хорошие, он создаёт новые ветви, как дерево, пускающее побеги и обрезка — если рост бесполезен, он прекращается, чтобы не тратить ресурсы.
Память сердца. Чтобы не забыть, какие ветви были самыми сильными, ACCS использует Heart Memory (HM) — это дневник, в который записываются лучшие решения. Эти записи являются ориентиром для роста, помогают новым капиллярам расти в правильном направлении.
Самообучение и адаптация. Если капилляр растёт в плохую сторону, алгоритм включает локальный поиск — он начинает копаться рядом, как корень, ищущий воду. Если капилляр вдруг оказывается лучшим — запускается глобальный поиск, как если бы дерево решило расти в новом направлении.
ACCS — это не сухая математика, а искусство обучения у природы. Ваше сердце всю жизнь решает сложнейшие оптимизационные задачи, и теперь алгоритмы могут использовать эту же мудрость: исследуй разнообразно (как коронарные артерии), помни лучшее (как память сердца), отпускай неудачи (как обрезка сосудов), балансируй между глобальным поиском и локальным уточнением.
Этот алгоритм напоминает нам, что лучшие решения часто уже есть в природе. Нужно лишь уметь их замечать и учиться у мудрости, которая бьется в груди у каждого из нас. Можем посмотреть, как это выглядит на иллюстрации.
Рисунок 1. Коронарная система
На изображении показаны основные элементы: схематическое изображение сердца с коронарными артериями. Левая коронарная артерия (LCA) с её ветвями: LAD и Circumflex, правая коронарная артерия (RCA), мелкие капилляры для демонстрации локального поиска, паттерн бифуркации (разветвления) справа в верхней части.
Концепции алгоритма. В нижней части показано, как биологические элементы соответствуют компонентам алгоритма:
Главные артерии → Глобальный поиск
Бифуркация → Фактор разветвления
Капилляры → Локальный поиск
Кровоток → CGF (фактор роста)
Это визуальное представление помогает понять, как природная система кровоснабжения сердца вдохновила на создание алгоритма оптимизации, где "артерии" исследуют пространство решений, а "капилляры" выполняют точную настройку найденных решений. Напишем псевдокод алгоритма.
Инициализация
Задать параметры: размер популяции (popSize), размер памяти сердца (heartMemorySize)
Создать начальную популяцию капилляров (агентов) со случайными позициями в пространстве решений
Инициализировать память сердца (Heart Memory) для хранения лучших решений
Основной цикл (до достижения критерия остановки)
Вычислить фактор роста коронарных сосудов (CGF) для каждого агента на основе их фитнес-значений
Выполнить глобальный поиск (рост артерий) — обновить позиции агентов, двигаясь к центру популяции или от него, в зависимости от CGF
Проверить границы и обновить память сердца
Выполнить локальный поиск (рост капилляров) — обновить позиции агентов, двигаясь в направлении лучшего агента и от худшего, с учетом фактора ангиогенеза
Проверить границы и обновить память сердца
Увеличить счетчик итераций
Вычисление CGF (Coronary Growth Factor)
Для каждого агента вычислить CGF как его фитнес, деленный на сумму фитнесов всех агентов (нормализация)
Глобальный поиск (Global Search)
Вычислить центр популяции (среднее по всем координатам)
Для каждого агента:
выбрать случайного другого агента (кроме себя);
определить направление движения (dr): если CGF центра меньше CGF текущего агента, то dr = -1 (двигаться от центра), иначе dr = 1 (двигаться к центру);
обновить позицию: новая позиция = позиция случайного агента + dr * CGF текущего агента * (центр - позиция случайного агента).
Локальный поиск (Local Search)
Вычислить фактор ангиогенеза (alpha) как angiogenesisPower * sqrt(текущая_итерация / максимальная_итерация)
Найти лучшего и худшего агента в текущей популяции
Для каждого агента обновить позицию: новая позиция = текущая позиция + alpha * случайное_число * (позиция_лучшего - позиция_худшего)
Обновление памяти сердца (Heart Memory)
Отсортировать агентов по фитнес-значению (убывание)
Сохранить лучших агентов (в количестве heartMemorySize) в память сердца
Критерий остановки
Достигнуто максимальное число итераций
Посмотрим на приведенную схему работы алгоритма.
Рисунок 2. Блок-схема алгоритма ACCS
Шаги алгоритма, отображенные на блок-схеме:
- инициализация популяции капилляров (случайные позиции),
- вычисление фитнес-функции для каждого капилляра,
- вычисление Coronary Growth Factor (CGF),
- глобальный поиск (движение к центру или от центра),
- локальный поиск (движение к лучшему и от худшего),
- обрезка (если новое положение хуже, возвращаемся),
- обновление памяти сердца,
- проверка критерия останова.
Теперь нам более-менее понятно, как все должно работать, тогда приступим к написанию кода алгоритма. Перед нами две связанные структуры данных, предназначенные для оптимизации и хранения информации о решениях.
Первая структура, называемая "Память сердца" (Heart Memory), предназначена для временного запоминания и оценки наилучших найденных решений и содержит:
- Позиция представляет собой набор числовых значений, определяющих конкретное решение точки в пространстве поиска. Эти значения можно рассматривать как координаты этого решения.
- Фитнес - числовое значение, которое указывает на "качество" соответствующей позиции. Чем выше фитнес, тем лучше решение.
- Инициализация - компонент структуры позволяет задать размер (количество измерений) для позиции и установить начальное значение фитнеса как крайне низкое, чтобы любое найденное решение считалось лучше.
Вторая структура, названная "Временная позиция" (TempPosition), используется для промежуточного хранения новых, только что сгенерированных или рассчитанных решений перед тем, как они будут оценены и сохранены в "Памяти сердца", она включает:
- Координаты — аналогично "позиции" в первой структуре, это набор числовых значений, определяющих конкретное решение.
- Фитнес — числовое значение, которое будет назначено этому решению после его оценки.
- Инициализация — подобно первой структуре, этот компонент позволяет определить размер (количество измерений) для координат и установить начальное значение фитнеса как крайне низкое, пока решение не будет полностью обработано.
//———————————————————————————————————————————————————————————————————— // Структура для хранения памяти сердца (Heart Memory) struct S_HeartMemory { double position []; // позиция в памяти double fitness; // фитнес позиции void Init (int dimensions) { ArrayResize (position, dimensions); fitness = -DBL_MAX; } }; // Структура для временного хранения новых позиций struct S_TempPosition { double coords []; // координаты double fitness; // фитнес void Init (int dimensions) { ArrayResize (coords, dimensions); fitness = -DBL_MAX; } }; //————————————————————————————————————————————————————————————————————
Класс "C_AO_ACCS" реализует алгоритм оптимизации, названный "Искусственная система кровообращения коронарных сосудов" (Artificial Coronary Circulation System, ACCS). Этот класс наследуется от базового класса "AO".
Общедоступные (public) поля класса:
- Деструктор — специальная функция, которая выполняется при уничтожении объекта этого класса, обеспечивая очистку ресурсов.
- Конструктор — функция вызывается при создании нового объекта и инициализирует основные параметры алгоритма:
- Устанавливает размер популяции (количество "капилляров") по умолчанию – 25.
- Устанавливает коэффициент бифуркации по умолчанию – 0.5.
- Создает структуру для хранения изменяемых параметров и записывает туда начальные значения "popSize" и "bifurcationRate".
- SetParams () — функция для установки или обновления параметров алгоритма. Она считывает текущие значения из перечисленных параметров, а также определяет размер "памяти сердца" как 25% от размера популяции, но не менее 1.
- Init () — функция предназначена для начальной инициализации алгоритма. Она принимает информацию о диапазонах поиска, шагах и количестве эпох (итераций).
- Moving () — функция отвечает за перемещение или обновление агентов (капилляров) в пространстве поиска.
- Revision () — функция занимается пересмотром и корректировкой решений на основе логики алгоритма.
- bifurcationRate — коэффициент бифуркации, который влияет на процесс создания новых решений и ветвления поиска.
Закрытые (private) поля класса:
- CalculateCGF () — внутренняя функция для расчета показателя, называемого "CGF", для каждого агента.
- CalculateCenterPosition () — внутренняя функция для определения центрального положения популяции.
- GlobalSearch () — внутренняя функция, отвечающая за глобальный поиск — исследование широкой области пространства решений.
- LocalSearch () — внутренняя функция, отвечающая за локальный поиск —более тщательное исследование области вокруг текущих решений.
- SelectionPhase () — внутренняя функция, реализующая фазу отбора — выбор лучших решений для дальнейшего развития.
- UpdateHeartMemory () — внутренняя функция для обновления "памяти сердца" лучшими найденными решениями.
- heartMemorySize — число, определяющее максимальное количество сохраняемых решений в "памяти сердца".
- heartMemory — массив объектов, представляющих собой "память сердца", где хранятся лучшие найденные решения.
- tempPos — массив временных объектов, используемых для хранения новых, еще не оцененных позиций, в основном для глобального поиска.
- cgf — массив, хранящий значения "CGF" для каждого агента в популяции.
- cgfCenter — скалярное значение, представляющее "CGF" центра популяции.
- centerCoords — массив, хранящий координаты центра популяции.
- centerFitness — числовое значение, представляющее качество (фитнес) центральной позиции.
- alpha — переменная, представляет собой коэффициент, связанный с процессом "ангиогенеза" (роста и развития).
- currentIteration — переменная, отслеживающая номер текущей итерации (шага) алгоритма.
- maxIterations — переменная, задающая максимальное количество итераций, которое может выполнить алгоритм.
- firstIteration — логический флаг, указывающий, является ли текущая итерация первой.
//———————————————————————————————————————————————————————————————————— class C_AO_ACCS : public C_AO { public: //---------------------------------------------------------- ~C_AO_ACCS () { } C_AO_ACCS () { ao_name = "ACCS"; ao_desc = "Artificial Coronary Circulation System"; ao_link = "https://www.mql5.com/ru/articles/19861"; popSize = 50; // размер популяции (количество капилляров) bifurcationRate = 0.5; // коэффициент бифуркации ArrayResize (params, 2); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "bifurcationRate"; params [1].val = bifurcationRate; } void SetParams () { popSize = (int)params [0].val; bifurcationRate = params [1].val; // Размер памяти сердца - 25% от популяции heartMemorySize = MathMax (1, (int)(popSize * 0.25)); } bool Init (const double &rangeMinP [], const double &rangeMaxP [], const double &rangeStepP [], const int epochsP); void Moving (); void Revision (); private: void CalculateCGF (); void CalculateCenterPosition (); void GlobalSearch (); void LocalSearch (); void SelectionPhase (); void UpdateHeartMemory (); //------------------------------------------------------------------ public: double bifurcationRate; // коэффициент бифуркации private: //--------------------------------------------------------- int heartMemorySize; // размер памяти сердца S_HeartMemory heartMemory []; // память сердца S_TempPosition tempPos []; // временные позиции для глобального поиска double cgf []; // массив CGF для каждого агента double cgfCenter; // CGF центра double centerCoords []; // координаты центра популяции double centerFitness; // фитнес центра double alpha; // текущий фактор ангиогенеза int currentIteration; // текущая итерация int maxIterations; // максимальное количество итераций bool firstIteration; // флаг первой итерации }; //————————————————————————————————————————————————————————————————————
Метод инициализации "Init" в классе "C_AO_ACCS" предназначен для подготовки параметров и структур данных перед запуском алгоритма оптимизации. Он принимает диапазоны поиска по переменным, шаги изменения и количество эпох (итераций). Процесс начинается с вызова стандартной функции инициализации, которая проверяет правильность заданных диапазонов и шагов. Если эта проверка не проходит, инициализация завершается с ошибкой.
Далее определяется размер "памяти сердца" как 25% от размера популяции, но не менее одного элемента. На основе этого создается массив структур "Память сердца", и каждому элементу присваиваются начальные параметры в виде "координат" (обозначенных как coords). Затем создается массив временных позиций, размером равным размеру популяции, для хранения новых решений, которые будут генерироваться на следующем этапе. Каждому элементу этого массива также задаются начальные параметры.
Также инициализируются массивы для хранения значений CGF для каждого агента и координат центра популяции. Последовательность завершается установкой текущей итерации в ноль, заданием максимального количества итераций согласно входным параметрам, установкой флага первой итерации в значение "истина" и начальным значением фактора ангиогенеза ("alpha"). В итоге, после выполнения этого метода алгоритм получает все необходимые структуры и параметры для начала оптимизации.
//———————————————————————————————————————————————————————————————————— //--- Инициализация bool C_AO_ACCS::Init (const double &rangeMinP [], const double &rangeMaxP [], const double &rangeStepP [], const int epochsP) { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; //------------------------------------------------------------------ // Размер памяти сердца - 25% от популяции heartMemorySize = MathMax (1, (int)(popSize * 0.25)); // Инициализация памяти сердца ArrayResize (heartMemory, heartMemorySize); for (int i = 0; i < heartMemorySize; i++) { heartMemory [i].Init (coords); } // Инициализация временных позиций ArrayResize (tempPos, popSize); for (int i = 0; i < popSize; i++) { tempPos [i].Init (coords); } // Инициализация массивов ArrayResize (cgf, popSize); ArrayResize (centerCoords, coords); currentIteration = 0; maxIterations = epochsP; firstIteration = true; alpha = 0.625; return true; } //————————————————————————————————————————————————————————————————————
Метод "CalculateCGF" предназначен для вычисления коэффициентов роста (CGF) для каждого агента в популяции с целью оценки их вклада в развитие системы.
Процесс начинается с определения минимального и максимального значений фитнеса среди всех решений. Если все фитнесы одинаковы, то каждому агенту присваивается равный CGF, равный 1, деленному на общее число агентов, чтобы обеспечить равноправие. Если же диапазон фитнесов разнообразен, то фитнесы каждого агента нормализуются с учетом минимального и максимального значения, и к результату добавляется небольшое смещение для стабилизации расчетов. После этого выполняется сумма всех нормализованных фитнесов. Каждому агенту присваивается (CGF) пропорционально его скорректированному фитнесу относительно суммы. Аналогично вычисляется (CGF) для центра популяции.
Этот метод обеспечивает взвешенное распределение влияния каждого решения на последующие этапы алгоритма в зависимости от их качества.
//———————————————————————————————————————————————————————————————————— //--- Вычисление CGF (Coronary Growth Factor) согласно Law 2 void C_AO_ACCS::CalculateCGF () { // Для максимизации: CGFi = fiti / Σfiti double minFit = DBL_MAX; double maxFit = -DBL_MAX; for (int i = 0; i < popSize; i++) { if (a [i].f < minFit) minFit = a [i].f; if (a [i].f > maxFit) maxFit = a [i].f; } double sumFitness = 0.0; // Если все фитнесы одинаковые if (MathAbs (maxFit - minFit) < 1e-10) { for (int i = 0; i < popSize; i++) { cgf [i] = 1.0 / popSize; } cgfCenter = 1.0 / popSize; return; } // Нормализуем фитнесы и вычисляем сумму for (int i = 0; i < popSize; i++) { double normalizedFit = (a [i].f - minFit) / (maxFit - minFit) + 0.1; sumFitness += normalizedFit; } // Вычисляем CGF для каждого капилляра for (int i = 0; i < popSize; i++) { double normalizedFit = (a [i].f - minFit) / (maxFit - minFit) + 0.1; cgf [i] = normalizedFit / sumFitness; } // CGF для центра double normalizedCenterFit = (centerFitness - minFit) / (maxFit - minFit) + 0.1; cgfCenter = normalizedCenterFit / sumFitness; } //————————————————————————————————————————————————————————————————————
Метод "CalculateCenterPosition" предназначен для вычисления центра популяции по координатам и фитнесу. Он начинается с обнуления массива координат центра и переменной для накопления фитнеса. Затем в цикле по всей популяции происходит суммирование координат каждого решения по каждой переменной, а также суммирование их фитнесов. После этого происходит деление накопленных сумм на размер популяции, чтобы получить среднее значение координат, являющееся координатой центра. Аналогично определяется средний фитнес, что дает оценку качества этого центра.
Этот метод помогает определить центральную точку всей популяции, что важно для последующих расчетов и формирования новых решений.
//———————————————————————————————————————————————————————————————————— //--- Вычисление центральной позиции (Law 3) void C_AO_ACCS::CalculateCenterPosition () { // Xc = mean(X), fitc = mean(fit) ArrayInitialize (centerCoords, 0.0); centerFitness = 0.0; for (int i = 0; i < popSize; i++) { for (int j = 0; j < coords; j++) { centerCoords [j] += a [i].c [j]; } centerFitness += a [i].f; } for (int j = 0; j < coords; j++) { centerCoords [j] /= popSize; } centerFitness /= popSize; } //————————————————————————————————————————————————————————————————————
Метод "GlobalSearch" реализует глобальный поиск новых положений для решений с целью развития главных артерий в популяции, основываясь на законе 4.
Он начинается с прохода по всей популяции, для каждого решения выбирается случайный агент (за исключением текущего). Затем рассчитывается фактор бифуркации, пропорциональный его "CGF", который влияет на величину изменения. Направление поиска определяется сравнением "CGF" текущего агента с центром популяции: если "CGF" текущего агента больше центра, направление выбирается в одну сторону, иначе — в противоположную. Для каждого координатного параметра вычисляется новое значение по формуле, которая зависит от выбранного направления, фактора бифуркации и случайного числа, что обеспечивает добавление элемента случайности и разнообразия. После этого новое значение координаты проверяется и, при необходимости, корректируется, чтобы не выходить за допустимые диапазоны с помощью метода "u.SeInDiSp".
Этот метод позволяет решению «вырасти» и переместиться в пространстве поиска, стимулируя исследование новых областей.
//———————————————————————————————————————————————————————————————————— //--- Глобальный поиск - рост главных артерий (Law 4) void C_AO_ACCS::GlobalSearch () { for (int i = 0; i < popSize; i++) { // Выбираем случайный капилляр r (кроме текущего) int r = i; while (r == i && popSize > 1) { r = (int)MathFloor (u.RNDfromCI (0.0, popSize - 0.001)); if (r >= popSize) r = popSize - 1; if (r < 0) r = 0; } // Фактор бифуркации Bf = CGFi double Bf = cgf [i] * bifurcationRate; // Определяем направление на основе сравнения CGF double dir; if (cgfCenter < cgf [i]) // Согласно документу { dir = -1.0; } else { dir = 1.0; } // Применяем формулу Law 4 for (int j = 0; j < coords; j++) { double rand_val = u.RNDfromCI (0.0, 1.0); // X^(t+1)_i,j = X^t_r,j + dir × Bf × (X^t_c,j - rand × X^t_r,j) tempPos [i].coords [j] = a [r].c [j] + dir * Bf * (centerCoords [j] - rand_val * a [r].c [j]); // Проверка границ tempPos [i].coords [j] = u.SeInDiSp (tempPos [i].coords [j], rangeMin [j], rangeMax [j], rangeStep [j]); } } } //————————————————————————————————————————————————————————————————————
Метод "LocalSearsh" реализует локальный поиск, направленный на развитие капилляров в рамках алгоритма. Начинается с обновления фактора роста капилляров, который зависит от текущей итерации и максимального числа итераций: чем больше прошедших итераций, тем выше значение фактора. Затем определяется наиболее подходящее и наименее подходящее решение в текущей популяции, чтобы на их основе провести локальную корректировку.
Для каждого решения и для каждой координаты поочередно вычисляется новое положение, которое смещается в сторону разницы между координатами лучших и худших решений, с учетом случайного веса и фактора роста. После вычисления новое значение проверяется и корректируется, чтобы не выходить за допустимый диапазон с помощью метода "u.SeInDiSp". Эта процедура способствует улучшению решений в локальной области поиска, усиливая их качество и сближение с оптимумом.
//———————————————————————————————————————————————————————————————————— //--- Локальный поиск - рост капилляров (Law 6) void C_AO_ACCS::LocalSearch () { // Обновляем фактор ангиогенеза: α = 0.625 × √(itr/itrmax) if (maxIterations > 0 && currentIteration > 0) { alpha = 0.625 * MathSqrt ((double)currentIteration / (double)maxIterations); } else { alpha = 0.625; } // Находим лучшую и худшую позиции в текущей популяции int bestIdx = 0, worstIdx = 0; for (int i = 1; i < popSize; i++) { if (a [i].f > a [bestIdx].f) bestIdx = i; if (a [i].f < a [worstIdx].f) worstIdx = i; } // Применяем локальный поиск (Law 6) for (int i = 0; i < popSize; i++) { for (int j = 0; j < coords; j++) { double rand_val = u.RNDfromCI (0.0, 1.0); // X^(t+1)_i,j = X^t_i,j + α × rand × (X^t_b,j - X^t_w,j) a [i].c [j] = a [i].c [j] + alpha * rand_val * (a [bestIdx].c [j] - a [worstIdx].c [j]); // Проверка границ a [i].c [j] = u.SeInDiSp (a [i].c [j], rangeMin [j], rangeMax [j], rangeStep [j]); } } } //————————————————————————————————————————————————————————————————————
Метод "SelectionPhase" реализует фазу селекции, в рамках которой происходит обновление текущих решений на основе результатов глобального поиска. Для каждого элемента в популяции происходит замена его текущих координат на новые, полученные ранее в процессе глобального поиска. Это делается путём копирования новых позиций из временных массивов в основные массивы решений. Таким образом, фаза селекции осуществляет переход к новым потенциально более эффективным решениям, подготовительным к следующему этапу алгоритма.
//———————————————————————————————————————————————————————————————————— //--- Фаза селекции (Law 5) void C_AO_ACCS::SelectionPhase () { // Применяем новые позиции из глобального поиска for (int i = 0; i < popSize; i++) { // Копируем новую позицию ArrayCopy (a [i].c, tempPos [i].coords, 0, 0, coords); } } //————————————————————————————————————————————————————————————————————
Метод "UpdateHeartMemory" занимается обновлением памяти сердца в алгоритме, что служит механизмом запоминания лучших найденных решений. Для этого все текущие решения сортируются по их значению функции оценки (фитнесу), причем в порядке убывания — лучшие оказываются в начале. После сортировки выбирается заданное число лучших решений, и их координаты вместе с соответствующими значениями фитнеса сохраняются в специальную память.
Этот процесс помогает сохранять лучшие решения и использовать их в дальнейшем для направления поиска, поддерживая баланс между исследованием и эксплуатацией пространства решений.
//———————————————————————————————————————————————————————————————————— //--- Обновление памяти сердца (Law 7) void C_AO_ACCS::UpdateHeartMemory () { // Создаем временный массив для сортировки struct S_IndexedAgent { int index; double fitness; }; S_IndexedAgent indexed []; ArrayResize (indexed, popSize); for (int i = 0; i < popSize; i++) { indexed [i].index = i; indexed [i].fitness = a [i].f; } // Сортировка пузырьком по убыванию фитнеса for (int i = 0; i < popSize - 1; i++) { for (int j = i + 1; j < popSize; j++) { if (indexed [j].fitness > indexed [i].fitness) { S_IndexedAgent temp = indexed [i]; indexed [i] = indexed [j]; indexed [j] = temp; } } } // Сохраняем лучшие решения в памяти сердца for (int i = 0; i < heartMemorySize; i++) { int idx = indexed [i].index; ArrayCopy (heartMemory [i].position, a [idx].c, 0, 0, coords); heartMemory [i].fitness = a [idx].f; } } //————————————————————————————————————————————————————————————————————
Основной шаг метода "Moving" алгоритма включает последовательное выполнение нескольких ключевых этапов. На начальном этапе происходит инициализация популяции — случайное создание начальных решений в пределах допустимых диапазонов с учетом заданных шагов, что осуществляется только один раз перед началом дальнейших итераций. После инициализации осуществляется обновление внутреннего счетчика итераций.
Далее алгоритм переходит к вычислению центральной позиции, которая служит опорным ориентиром для поиска. Затем рассчитывается функция оценки капилляров (CGF), которая помогает определить важность и вклад каждого элемента. После этого выполняется глобальный поиск новых решений на основе полученных данных, что расширяет исследуемое пространство. В завершение каждого цикла происходит процесс селекции, в ходе которого текущие решения обновляются, заменяя их на новые, полученные в ходе поиска. Этот цикл повторяется для постепенного улучшения решений.
//———————————————————————————————————————————————————————————————————— //--- Основной шаг алгоритма void C_AO_ACCS::Moving () { // Инициализация популяции (Law 1) if (!revision) { for (int i = 0; i < popSize; i++) { for (int j = 0; j < coords; j++) { a [i].c [j] = u.RNDfromCI (rangeMin [j], rangeMax [j]); a [i].c [j] = u.SeInDiSp (a [i].c [j], rangeMin [j], rangeMax [j], rangeStep [j]); } } revision = true; firstIteration = true; currentIteration = 0; return; } currentIteration++; // Вычисляем центральную позицию (Law 3) CalculateCenterPosition (); // Вычисляем CGF для всех капилляров (Law 2) CalculateCGF (); // Выполняем глобальный поиск (Law 4) GlobalSearch (); // Применяем селекцию (Law 5) SelectionPhase (); } //————————————————————————————————————————————————————————————————————
Метод "Revision" отвечает за проверку текущих решений и обновление их данных для дальнейшего использования в алгоритме.
Сначала при первой итерации инициализируются личные лучшие позиции каждого агента, а также запоминается лучшее решение всей популяции, что способствует сохранению наиболее успешных решений. Затем для каждой особи сохраняется её текущая позиция и значение функции оценки как предыдущие. После этого происходит сравнение новых решений с лучшими личными решениями: если новая позиция хуже, есть вероятность их отката к личной лучшей позиции (обрезка), что помогает избегать ухудшения результатов. Если решение улучшилось, оно становится новым личным лучшим.
Далее выполняется локальный поиск для совершенствования решений, обновляется память сердца с помощью соответствующего метода, и наконец, проверяется и обновляется глобально лучшее решение всей популяции.
//———————————————————————————————————————————————————————————————————— //--- Проверка и обновление результатов void C_AO_ACCS::Revision () { if (firstIteration) { firstIteration = false; // Инициализируем личные лучшие позиции for (int i = 0; i < popSize; i++) { a [i].fB = a [i].f; ArrayCopy (a [i].cB, a [i].c, 0, 0, coords); } // Инициализируем память сердца UpdateHeartMemory (); } // Сохраняем предыдущие позиции и фитнесы for (int i = 0; i < popSize; i++) { ArrayCopy (a [i].cP, a [i].c, 0, 0, coords); a [i].fP = a [i].f; } // После оценки фитнеса новых позиций из глобального поиска, // проверяем улучшение (Law 5 - селекция и обрезка) for (int i = 0; i < popSize; i++) { // Если новая позиция хуже предыдущей лучшей этого агента if (a [i].f < a [i].fB) { // Вероятность обрезки (pruning) double pruningProb = 0.2; if (u.RNDfromCI (0.0, 1.0) < pruningProb) { // Обрезка - возврат к личной лучшей позиции ArrayCopy (a [i].c, a [i].cB, 0, 0, coords); a [i].f = a [i].fB; } } else { // Обновляем личное лучшее решение агента a [i].fB = a [i].f; ArrayCopy (a [i].cB, a [i].c, 0, 0, coords); } } // Выполняем локальный поиск (Law 6) LocalSearch (); // Обновляем память сердца (Law 7) UpdateHeartMemory (); // Обновляем глобальное лучшее решение for (int i = 0; i < popSize; i++) { if (a [i].f > fB) { fB = a [i].f; ArrayCopy (cB, a [i].c, 0, 0, WHOLE_ARRAY); } } } //————————————————————————————————————————————————————————————————————
Результаты тестов
Результаты тестов, мягко говоря, слабые. Но есть одно большое "НО", и об этом ниже.
ACCS|Artificial Coronary Circulation System|50.0|0.5|
=============================
5 Hilly's; Func runs: 10000; result: 0.5388483416731469
25 Hilly's; Func runs: 10000; result: 0.40315510603699484
500 Hilly's; Func runs: 10000; result: 0.2750619992528315
=============================
5 Forest's; Func runs: 10000; result: 0.4373687177939665
25 Forest's; Func runs: 10000; result: 0.24807871438181
500 Forest's; Func runs: 10000; result: 0.17536977563388764
=============================
5 Megacity's; Func runs: 10000; result: 0.3692307692307693
25 Megacity's; Func runs: 10000; result: 0.2116923076923077
500 Megacity's; Func runs: 10000; result: 0.10640000000000094
=============================
All score: 2.76521 (30.72%)
Запустим тестовый скрипт с алгоритмом. В первую очередь бросается в глаза, что характер движения агентов в пространстве поиска сильно меняется в зависимости от характера поверхности исследуемой функции, что, собственно, является отличительной чертой алгоритмов оптимизации, заслуживающих пристального внимания.
ACCS на тестовой функции Hilly
ACCS на тестовой функции Forest
ACCS на тестовой функции Megacity
Механизм глобального поиска посредством движения относительно центра популяции с учетом направления, оказывается достаточно эффективным для определенных типов задач, где экстремумы находятся строго в центре функции. Алгоритм их решает легко, потому что стратегия поиска построена на усреднении, простое совпадение дает поисковое преимущество, поэтому для "справедливой" работы алгоритма необходимы функции с нетривиальными задачами.
На всех подобных видах стандартных функций алгоритм "справляется" превосходно, что однако совершенно говорит об обратном, когда встречаются более сложные ландшафты, как на наших тестовых функциях (выше). Есть и другая версия (которая требует проверки) —результатом прекрасной сходимости на этих функциях с экстремумом в центре может быть тот факт, что эти функции симметричные одновременно в двух плоскостях.
ACCS на стандартной тестовой функции Paraboloid
ACCS на стандартной тестовой функции Ackley
ACCS на стандартной тестовой функции Rastrigin
В рейтинговой таблице алгоритм ACCS представлен ознакомительно.
| № | 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 | DOAdingom | dingo_optimization_algorithm_M | 0,47968 | 0,45367 | 0,46369 | 1,39704 | 0,94145 | 0,87909 | 0,91454 | 2,73508 | 0,78615 | 0,86061 | 0,84805 | 2,49481 | 6,627 | 73,63 |
| 2 | 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 |
| 3 | 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 |
| 4 | 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 |
| 5 | (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 |
| 6 | 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 |
| 7 | 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 |
| 8 | 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 |
| 9 | 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 |
| 10 | 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 |
| 11 | 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 |
| 12 | 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 |
| 13 | EOm | extremal_optimization_M | 0,76166 | 0,77242 | 0,31747 | 1,85155 | 0,99999 | 0,76751 | 0,23527 | 2,00277 | 0,74769 | 0,53969 | 0,14249 | 1,42987 | 5,284 | 58,71 |
| 14 | BBO | biogeography based optimization | 0,94912 | 0,69456 | 0,35031 | 1,99399 | 0,93820 | 0,67365 | 0,25682 | 1,86867 | 0,74615 | 0,48277 | 0,17369 | 1,40261 | 5,265 | 58,50 |
| 15 | 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 |
| 16 | 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 |
| 17 | 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 |
| 18 | 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 |
| 19 | 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 |
| 20 | 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 |
| 21 | 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 |
| 22 | BSA | backtracking_search_algorithm | 0,97309 | 0,54534 | 0,29098 | 1,80941 | 0,99999 | 0,58543 | 0,21747 | 1,80289 | 0,84769 | 0,36953 | 0,12978 | 1,34700 | 4,959 | 55,10 |
| 23 | 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 |
| 24 | 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 |
| 25 | 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 |
| 26 | 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 |
| 27 | DOA | dream_optimization_algorithm | 0,85556 | 0,70085 | 0,37280 | 1,92921 | 0,73421 | 0,48905 | 0,24147 | 1,46473 | 0,77231 | 0,47354 | 0,18561 | 1,43146 | 4,825 | 53,62 |
| 28 | 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 |
| 29 | DEA | dolphin_echolocation_algorithm | 0,75995 | 0,67572 | 0,34171 | 1,77738 | 0,89582 | 0,64223 | 0,23941 | 1,77746 | 0,61538 | 0,44031 | 0,15115 | 1,20684 | 4,762 | 52,91 |
| 30 | 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 |
| 31 | 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 |
| 32 | 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 |
| 33 | 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 |
| 34 | (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 |
| 35 | FBA | fractal-based Algorithm | 0,79000 | 0,65134 | 0,28965 | 1,73099 | 0,87158 | 0,56823 | 0,18877 | 1,62858 | 0,61077 | 0,46062 | 0,12398 | 1,19537 | 4,555 | 50,61 |
| 36 | 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 |
| 37 | 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 |
| 38 | 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 |
| 39 | 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 |
| 40 | 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 |
| 41 | CAm | camel algorithm M | 0,78684 | 0,56042 | 0,35133 | 1,69859 | 0,82772 | 0,56041 | 0,24336 | 1,63149 | 0,64846 | 0,33092 | 0,13418 | 1,11356 | 4,444 | 49,37 |
| 42 | 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 |
| 43 | CMAES | covariance_matrix_adaptation_evolution_strategy | 0,76258 | 0,72089 | 0,00000 | 1,48347 | 0,82056 | 0,79616 | 0,00000 | 1,61672 | 0,75846 | 0,49077 | 0,00000 | 1,24923 | 4,349 | 48,33 |
| 44 | DA_duelist | duelist_algorithm | 0,92782 | 0,53778 | 0,27792 | 1,74352 | 0,86957 | 0,47536 | 0,18193 | 1,52686 | 0,62153 | 0,33569 | 0,11715 | 1,07437 | 4,345 | 48,28 |
| 45 | 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 |
| ACCS | artificial_coronary_circulation_system | 0,53885 | 0,40316 | 0,27507 | 1,21708 | 0,43737 | 0,24807 | 0,17537 | 0,86081 | 0,36923 | 0,21169 | 0,10640 | 0,68732 | 2,765 | 30,72 | |
| RW | random walk | 0,48754 | 0,32159 | 0,25781 | 1,06694 | 0,37554 | 0,21944 | 0,15877 | 0,75375 | 0,27969 | 0,14917 | 0,09847 | 0,52734 | 2,348 | 26,09 | |
Выводы
Алгоритм ACCS представляет собой интересную попытку перенести биологическую модель роста коронарных артерий на задачи оптимизации, однако его практическая реализация выявила существенные ограничения. Результат в 30% от максимально возможного указывает на фундаментальные проблемы в механике алгоритма, которые не позволяют ему конкурировать с лучшими методами оптимизации. Основная слабость заключается в чрезмерной зависимости от текущего распределения популяции через механизм "CGF", что приводит к преждевременной сходимости и недостаточному исследованию пространства поиска.
Механизм глобального поиска посредством движения относительно центра популяции с учетом направления, определяемого сравнением "CGF", оказывается недостаточно эффективным для выхода из локальных оптимумов, особенно на сложных мультимодальных ландшафтах. Локальный поиск, основанный на движении между лучшим и худшим решениями с убывающим фактором ангиогенеза, возможно слишком упрощен и не учитывает топологию пространства поиска.
Память сердца, хранящая 25% лучших решений, фактически дублирует функциональность элитизма, но не используется активно для направления поиска, что делает её скорее пассивным архивом, чем активным компонентом алгоритма. Биологическая метафора, хотя и концептуально привлекательна, не транслируется в эффективные вычислительные механизмы — процессы роста артерий, бифуркации и обрезки в реальной биологической системе управляются сложными химическими градиентами и механическими напряжениями, которые трудно адекватно моделировать простыми математическими формулами.
Попытка объединить глобальный и локальный поиск через последовательное применение двух разных стратегий движения приводит к конфликту между исследованием и эксплуатацией, а не к их синергии. Я пробовал делать несколько версий алгоритма с небольшими изменениями в очередности стратегий поиска и их модификации так, чтобы не отклоняться от идеи, но это не принесло значительного улучшения, поэтому оставляю все как есть. Для любителей поэкспериментировать — у вас есть все возможности и инструменты для улучшения результатов. Кроме того, остается открытым вопрос в рамках этой статьи, о природе высокой эффективности на некоторых задачах.
Рисунок 3. Цветовая градация алгоритмов по соответствующим тестам
Рисунок 4. Гистограмма результатов тестирования алгоритмов (по шкале от 0 до 100, чем больше, тем лучше, где 100 — максимально возможный теоретический результат, в архиве скрипт для расчета рейтинговой таблицы)
Плюсы и минусы алгоритма ACCS:
Плюсы:
- Мало внешних параметров.
- Чрезвычайно эффективен на некоторых типах задач (даже высоких размерностей).
Минусы:
- Слабая сходимость на сложных ландшафтах.
К статье прикреплён архив с актуальными версиями кодов алгоритмов. Автор статьи не несёт ответственности за абсолютную точность в описании канонических алгоритмов, во многие из них были внесены изменения для улучшения поисковых возможностей. Выводы и суждения, представленные в статьях, основываются на результатах проведённых экспериментов.
Программы, используемые в статье
| # | Имя | Тип | Описание |
|---|---|---|---|
| 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_ACCS.mq5 | Скрипт | Испытательный стенд для ACCS |
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.
От начального до среднего уровня: Struct (V)
Автоматизация торговых стратегий на MQL5 (Часть 14): Стратегия каскадной торговли с MACD-RSI и статистическими методами
Разработка инструментария для анализа движения цен (Часть 11): Советник Heikin Ashi Signal
Разрабатываем менеджер терминалов (Часть 2): Запуск нескольких экземпляров
- Бесплатные приложения для трейдинга
- 8 000+ сигналов для копирования
- Экономические новости для анализа финансовых рынков
Вы принимаете политику сайта и условия использования