Búsqueda oscilatoria determinista (DOS) — Deterministic Oscillatory Search (DOS)
25
0
Contenido
Introducción
En el campo moderno de la optimización, existe una evolución constante de algoritmos que buscan superar las limitaciones fundamentales de los métodos tradicionales. La mayoría de los algoritmos de optimización metaheurística se basan en gran medida en procesos estocásticos y números aleatorios. Aunque estos enfoques demuestran una capacidad impresionante para evitar óptimos locales, su naturaleza no determinista puede crear problemas en áreas que requieren una reproducibilidad precisa de los resultados.
En el artículo de hoy, le presentamos la búsqueda oscilatoria determinista (DOS), un nuevo algoritmo metaheurístico que combina las ventajas de los métodos tradicionales basados en gradientes con la eficiencia de los algoritmos de enjambre, pero evita por completo el uso de números aleatorios.
Desarrollado para resolver problemas complejos de optimización global en 2017 por Archana, DOS se basa en el concepto de movimiento de partículas oscilantes en un espacio de búsqueda con una distribución determinista de posiciones iniciales. La característica clave del algoritmo es su capacidad de gestionar problemas multidimensionales manteniendo la reproducibilidad total: dadas las mismas condiciones iniciales, el algoritmo siempre llega al mismo resultado.
A diferencia de la mayoría de los algoritmos metaheurísticos, el DOS introduce el concepto de "pendiente de aptitud", un mecanismo que permite a las partículas reconocer la calidad de su movimiento y adaptar su estrategia de búsqueda. Las partículas pueden encontrarse en uno de tres estados de pendiente: positivo (el movimiento mejora la solución), negativo (el movimiento empeora la solución) o desconocido.
Esta información se usa para controlar el comportamiento oscilatorio de las partículas. Cuando los métodos de gradiente convencionales llegan a un punto en que todas las direcciones provocan un empeoramiento de la función objetivo, se detienen. El DOS supera esta limitación mediante un mecanismo de enjambre que se activa cuando el movimiento oscilante no ofrece mejoras. En este caso, la partícula comienza a moverse en la dirección de la solución global más conocida.
En este artículo, analizaremos con detalle los fundamentos matemáticos del algoritmo DOS, analizaremos sus características y funciones de implementación y demostraremos su eficacia en una serie de problemas de prueba.
Implementación del algoritmo
Ahora veamos cómo funciona el algoritmo DOS. En lugar de un paseo aleatorio, usa un enfoque sistemático que consta de unas pocas reglas simples; el DOS no se basa en la aleatoriedad. El algoritmo comienza colocando varios "exploradores" (partículas) en diferentes puntos del paisaje. La ubicación no es aleatoria: se efectúa según una fórmula específica para cubrir uniformemente toda la región. Cada explorador tiene una dirección inicial y una velocidad de movimiento. Conforme el explorador avanza, este recuerda si el terreno se vuelve más alto (mejor) o más bajo (peor). Esto se llama "pendiente" y es una forma sencilla de saber si se está moviendo en la dirección correcta.
Ahora empieza lo interesante. Cuando un explorador descubre que ha dejado de ascender y ha comenzado a descender (su aptitud ha empeorado), no se detiene sin más, ni retrocede. En lugar de ello, hace un "rebote": da una vuelta y continúa moviéndose en la dirección opuesta, pero a una velocidad más lenta (la mitad de su velocidad anterior). Es como una pelota de tenis que rebota en una pared, pero con menos energía de la que traía.
Este proceso de rebote crea un movimiento oscilante; de ahí viene el nombre del algoritmo. Con cada rebote, el explorador localiza el punto extremo con mayor precisión. ¿Pero qué pasa si el explorador queda atrapado, por ejemplo, en una pequeña colina, y a su alrededor todo se va volviendo más bajo, y este extremo no es el punto más alto de la región? Aquí el DOS utiliza una técnica diferente. Si el explorador intenta moverse en distintas direcciones, pero encuentra un descenso en todas partes, cambia a otro modo: "enjambre". En este modo, comienza a moverse hacia el mejor punto encontrado por todos los exploradores hasta el momento.
A diferencia de la enumeración aleatoria o el ensayo y error, el DOS explora sistemáticamente el espacio de soluciones utilizando información sobre la dirección de la mejora y la experiencia colectiva de todos los exploradores. Al mismo tiempo, no requiere cálculos complejos de derivadas ni almacenar una gran historia de búsqueda. Así, paso a paso, aplicando reglas simples de movimiento, reflexión y enjambre, el DOS encuentra soluciones óptimas a problemas complejos.
La figura de más abajo muestra los siguientes aspectos clave del algoritmo: un espacio de búsqueda bidimensional con un óptimo global y varios óptimos locales, representados por líneas de contorno, y una ruta desde el punto de partida hasta el óptimo global, demostrando el comportamiento característico del algoritmo DOS:
- posición determinista inicial de la partícula,
- movimiento oscilante (en zigzag) al explorar el espacio,
- movimiento adaptativo hacia el óptimo global.
Los componentes clave del algoritmo son: la inicialización de partículas deterministas, el uso del concepto de pendiente de aptitud, el movimiento oscilatorio y un mecanismo de enjambre (movimiento hacia la mejor solución conocida).
El estado de la pendiente, que puede ser:
- positivo (+1) - el movimiento actual mejora la aptitud,
- negativo (-1) - el movimiento actual empeora la aptitud,
- desconocido (0) - estado durante la inicialización o después de un cambio de estrategia.
Figura 1. Ilustración del funcionamiento del algoritmo
La ilustración muestra claramente cómo el DOS combina las características de los métodos de gradiente clásicos (búsqueda local a través de oscilaciones) con las capacidades de los algoritmos de enjambre, manteniendo al mismo tiempo un comportamiento totalmente determinista. Una vez aclarados los principios del algoritmo, podemos escribir el pseudocódigo del algoritmo.
Paso 1: Preparación básica
- Creamos arrays para almacenar las posiciones, velocidades, valores de aptitud anteriores y pendientes para cada partícula
- Inicializamos la mejor solución encontrada con el valor de aptitud mínimo posible
Segundo paso: Inicialización determinista de partículas
- Para cada partícula:
- la ubicamos en el espacio de búsqueda utilizando una fórmula determinista que garantiza una cobertura uniforme
- establecemos la velocidad inicial en cero
- establecemos la pendiente inicial en "desconocida" (0)
- establecemos el valor de aptitud anterior en el valor mínimo posible
Paso 3: Ciclo de optimización principal
- Repetimos hasta alcanzar el número máximo de iteraciones: Parte 1: Movimiento de partículas
- Para cada partícula:
- guardar el valor de aptitud actual como el anterior
- actualizamos la posición agregando la velocidad actual
- Si la nueva posición está fuera de los límites de búsqueda, las limitamos a los rangos permitidos
- Para cada partícula:
- Calcular el nuevo valor de aptitud
- si la aptitud es mejor que la mejor solución encontrada, actualizamos la mejor solución
- si la pendiente es "desconocida" (0):
- si la nueva aptitud es mejor que la anterior, establecemos la pendiente en "positiva" (1)
- si la nueva aptitud es peor que la anterior, establecemos la pendiente en "negativa" (-1)
- si la aptitud no ha cambiado, dejamos la pendiente como "desconocida"
- si la pendiente es "positiva" (1):
- si la nueva aptitud es peor que la anterior:
- cambiamos la dirección del movimiento a la opuesta
- reducimos la velocidad a la mitad
- establecemos la pendiente en "negativa" (-1)
- si la nueva aptitud es peor que la anterior:
- si la pendiente es "negativa" (-1):
- si la nueva aptitud es peor que la anterior:
- aplicamos el mecanismo de enjambre: sumamos a la velocidad actual el vector dirigido a la mejor solución, multiplicado por el factor de movimiento
- establecemos la pendiente en "desconocida" (0)
- si la nueva aptitud es peor que la anterior:
- comprobamos si la velocidad es cero o cercana a cero:
- si la velocidad es casi cero:
- establecemos la velocidad en la dirección de la mejor solución encontrada, multiplicada por el factor de movimiento
- establecemos la pendiente en "desconocida" (0)
- si la velocidad es casi cero:
- Para cada partícula:
Paso 4: Conclusión
- Devolvemos la mejor solución encontrada y su valor de aptitud
Ahora podemos comenzar a escribir el código del algoritmo DOS. Así, vamos a crear una estructura para almacenar el estado de la partícula durante el proceso de optimización. Esta estructura contendrá un campo para definir la pendiente de velocidad (positiva, negativa o indefinida) y un array de componentes de velocidad por dimensiones, lo que permitirá el almacenamiento y procesamiento cómodo de los parámetros de movimiento de partículas.
Para inicializar la estructura, ofrecemos un método que establece la pendiente en un valor predeterminado y crea un array de velocidad de un tamaño determinado, rellenándolo con ceros, lo que asegura un estado inicial correcto antes de comenzar a trabajar.
Además, hemos implementado una comprobación de velocidad cero: un método que comprueba todos los componentes de velocidad y devuelve "true" si todos son prácticamente cero dada la precisión especificada, o "false" en caso contrario. Esto ayuda a determinar si la partícula ha alcanzado un estado estable o necesita continuar moviéndose.
// Структура для хранения скорости частицы struct S_DOS_Velocity { int slope; // Наклон частицы (-1: отрицательный, 0: неизвестный, 1: положительный) double v []; // Компоненты скорости по каждому измерению void Init (int dims) { slope = 0; ArrayResize (v, dims); ArrayInitialize (v, 0.0); // Быстрая инициализация нулями всего массива } // Проверка на нулевую скорость bool IsZero (double epsilon = 1e-10) { for (int i = 0; i < ArraySize (v); i++) if (MathAbs (v [i]) > epsilon) return false; return true; } }; //——————————————————————————————————————————————————————————————————————————————
La clase "C_AO_DOS" representará la implementación del algoritmo, y heredará la funcionalidad de la clase básica "C_AO", agregando la lógica específica para el método DOS. Las principales características de la clase: el constructor inicializa los parámetros por defecto, incluido el tamaño de la población y el factor de movimiento hacia la mejor solución, y crea un array de parámetros. El método "SetParams()" ofrece la capacidad de establecer y verificar parámetros como el tamaño de la población "popSize" y el factor de movimiento "movementFactor", sujeto a restricciones. El método "Init()" se encarga de preparar las condiciones iniciales: los rangos de búsqueda, los pasos de cambio y el número de iteraciones.
Lógica del movimiento de partículas, métodos:- Moving () - implementa el mecanismo básico para desplazar las partículas en el espacio de búsqueda, según las velocidades y estimaciones actuales.
- Revision () - se utiliza para ajustar posiciones o velocidades después de cada paso.
Dentro de la clase, se define la estructura "S_DOS_Velocity velocities", que almacena los componentes de velocidad de cada partícula en todas las dimensiones y contiene métodos para la inicialización y prueba de velocidad cero.
Métodos internos:- InitializeParticles () y ProcessParticleMovement () son funciones auxiliares para inicializar y actualizar las posiciones de las partículas y proporcionan lógica algorítmica.
En general, la clase implementa un enfoque estructurado del método DOS, donde cada número y variable tiene como objetivo guiar la exploración del espacio de soluciones usando partículas, velocidades y direcciones.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_DOS : public C_AO { public: //-------------------------------------------------------------------- ~C_AO_DOS () { } C_AO_DOS () { ao_name = "DOS"; ao_desc = "Deterministic Oscillatory Search"; ao_link = "https://www.mql5.com/ru/articles/18154"; // Установка параметров по умолчанию popSize = 30; // размер популяции movementFactor = 0.95; // фактор движения к лучшему решению // Создание и инициализация массива параметров ArrayResize (params, 2); params [0].name = "Population Size"; params [0].val = popSize; params [1].name = "Movement Factor"; params [1].val = movementFactor; } void SetParams () { // Установка значений параметров с проверкой popSize = (int)MathMax (5, params [0].val); // Минимально 5 частиц для эффективности movementFactor = MathMax (0.1, MathMin (1.0, params [1].val)); // Ограничение от 0.1 до 1.0 } bool Init (const double &rangeMinP [], // минимальные значения const double &rangeMaxP [], // максимальные значения const double &rangeStepP [], // шаг изменения const int epochsP = 0); void Moving (); void Revision (); //---------------------------------------------------------------------------- double movementFactor; // фактор движения к лучшему решению S_DOS_Velocity velocities []; // Массив структур скоростей частиц private: //------------------------------------------------------------------- void InitializeParticles (); void ProcessParticleMovement (int particleIndex); }; //——————————————————————————————————————————————————————————————————————————————
El método "Init" es responsable de preparar el algoritmo para su ejecución. En primer lugar, llamamos al método básico de inicialización, que configura los rangos de búsqueda iniciales y los pasos necesarios para la operación. Después de realizar la inicialización básica con éxito, asignamos memoria para los arrays en los que se almacenará información sobre las velocidades de las partículas.
Para cada elemento de la población, se calculan las velocidades iniciales en todas las dimensiones para determinar la dinámica inicial del movimiento de las partículas. Finalmente, se llama un método que coloca las partículas en sus posiciones iniciales de una forma determinista concreta, especificando sus puntos de inicio en el espacio de búsqueda.
El resultado de este método es una población ya preparada de partículas con ciertas condiciones iniciales, lista para comenzar el proceso de búsqueda iterativa.
//—————————————————————————————————————————————————————————————————————————————— bool C_AO_DOS::Init (const double &rangeMinP [], // минимальные значения const double &rangeMaxP [], // максимальные значения const double &rangeStepP [], // шаг изменения const int epochsP = 0) // количество эпох { // Стандартная инициализация C_AO if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; //---------------------------------------------------------------------------- // Выделение памяти под массивы ArrayResize (velocities, popSize); // Инициализация скоростей для каждого измерения for (int i = 0; i < popSize; i++) velocities [i].Init (coords); // Инициализация позиций частиц детерминистическим способом InitializeParticles (); return true; } //——————————————————————————————————————————————————————————————————————————————
El método "Moving" implementa el desplazamiento de las partículas en el espacio de búsqueda del algoritmo DOS y procesa secuencialmente cada partícula de la población, iterándolas desde la primera hasta la última. Para cada partícula, se almacena su valor de función de aptitud actual "f". Esto es necesario para su posterior comparación, y también para determinar la mejora o el deterioro de la posición de la partícula.
Para cada coordenada (dimensión) de la partícula, se calcula un nuevo valor añadiendo el componente de velocidad correspondiente a la coordenada actual. Las nuevas coordenadas están limitadas a los rangos especificados "rangeMin [d]" y "rangeMax [d]" según el paso, de modo que las partículas no vayan más allá del área de búsqueda permitida.
Como resultado, el método "Moving" cambia las posiciones de las partículas en el espacio de búsqueda, preservando la información sobre su estado anterior y asegurando la exactitud de las nuevas coordenadas, considerando las restricciones y la discretización.
//+----------------------------------------------------------------------------+ //| Основной метод движения частиц | //+----------------------------------------------------------------------------+ void C_AO_DOS::Moving () { // Обработка всех частиц for (int i = 0; i < popSize; i++) { // Сохранение значения фитнеса a [i].fP = a [i].f; // Вычисление новых координат на основе скорости for (int d = 0; d < coords; d++) { // Обновление позиции a [i].c [d] += velocities [i].v [d]; // Округление до ближайшего допустимого шага a [i].c [d] = u.SeInDiSp (a [i].c [d], rangeMin [d], rangeMax [d], rangeStep [d]); } } } //——————————————————————————————————————————————————————————————————————————————
El método "Revision" se encarga de actualizar la información sobre las mejores soluciones y procesar el movimiento de las partículas durante el proceso de búsqueda. El método procesa secuencialmente todas las partículas de la población. Para cada una de ellas, se verifica si la solución actual de la partícula mejora el mejor valor de aptitud global "fB". Si es así, actualizamos la mejor puntuación global y guardamos las coordenadas correspondientes. Para cada partícula, se llama un método aparte, que es responsable de recalcular y ajustar su posición según los cambios en la función de aptitud.
El resultado del funcionamiento del método será la actualización de las mejores soluciones y la preparación del sistema para la siguiente etapa de la búsqueda, cuando las partículas pueden continuar moviéndose considerando las últimas actualizaciones.
//+----------------------------------------------------------------------------+ //| Метод обновления фитнес-функций | //+----------------------------------------------------------------------------+ void C_AO_DOS::Revision () { // Обработка каждой частицы 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); } // Обработка движения частицы на основе изменения фитнеса ProcessParticleMovement (i); } } //——————————————————————————————————————————————————————————————————————————————
El método "ProcessParticleMovement" se encarga de ajustar el movimiento de una partícula individual en el espacio de búsqueda según los cambios en su función de aptitud y las direcciones actuales. Si el índice no es válido, el método finalizará. Para acelerar el acceso, se guardan la partícula de aptitud actual, el valor de aptitud anterior y la pendiente de movimiento actual. Según la diferencia entre la aptitud actual y la anterior, así como de la pendiente actual, el algoritmo decide qué dirección elegir para que se mueva la partícula si:
- la pendiente es desconocida, su dirección (positiva, negativa o indefinida) se determina según el cambio de aptitud;
- la pendiente era positiva, pero la aptitud ha empeorado, la pendiente cambia a negativa y las velocidades a lo largo de todos los ejes se reducen a la mitad, lo que contribuye a un cambio en la dirección del movimiento;
- La pendiente era negativa y la aptitud se ha deteriorado, se produce un "enjambre", un movimiento hacia el óptimo global en el que las velocidades a lo largo de los ejes aumentan hacia la mejor solución.
Si las velocidades en todas las direcciones son cero, el movimiento hacia el óptimo global se inicia estableciendo la velocidad según la diferencia entre las coordenadas actuales y las coordenadas de la mejor solución global, considerando el coeficiente de movimiento. Como resultado, la dirección y la magnitud de la velocidad se ajustan dependiendo de la situación, lo cual permite que la partícula responda adecuadamente a los cambios de aptitud y "aprenda" a moverse en la dirección óptima.
El objetivo final del método es posibilitar un movimiento dinámico y adaptativo de las partículas, considerando los cambios en sus soluciones locales y globales para una búsqueda efectiva del óptimo.
//+----------------------------------------------------------------------------+ //| Обработка движения частицы после обновления фитнеса | //+----------------------------------------------------------------------------+ void C_AO_DOS::ProcessParticleMovement (int particleIndex) { // Локальные переменные для оптимизации доступа double currentFitness = a [particleIndex].f; double previousFitness = a [particleIndex].fP; int currentSlope = velocities [particleIndex].slope; // Сравнение фитнесов для определения направления движения double fitnessDiff = currentFitness - previousFitness; // Обработка наклона в соответствии с текущим состоянием if (currentSlope == 0) // Неизвестный наклон { // Определяем наклон на основе изменения фитнеса velocities [particleIndex].slope = (fitnessDiff > 0) ? 1 : (fitnessDiff < 0) ? -1 : 0; } else if (currentSlope == 1 && fitnessDiff < 0) // Положительный наклон и ухудшение фитнеса { // Меняем направление и уменьшаем скорость for (int d = 0; d < coords; d++) velocities [particleIndex].v [d] *= -0.5; // Оптимизированная форма деления на 2 velocities [particleIndex].slope = -1; // Меняем наклон на отрицательный } else if (currentSlope == -1 && fitnessDiff < 0) // Отрицательный наклон и ухудшение фитнеса { // Применяем механизм роения - движение к глобальному оптимуму for (int d = 0; d < coords; d++) velocities [particleIndex].v [d] += (cB [d] - a [particleIndex].c [d]) * movementFactor; velocities [particleIndex].slope = 0; // Сбрасываем наклон как неизвестный } // Проверка на нулевую скорость с использованием метода структуры if (velocities [particleIndex].IsZero ()) { // Инициализируем скорость движением к глобальному оптимуму for (int d = 0; d < coords; d++) velocities [particleIndex].v [d] = (cB [d] - a [particleIndex].c [d]) * movementFactor; // Сбрасываем наклон velocities [particleIndex].slope = 0; } } //——————————————————————————————————————————————————————————————————————————————
Resultados de las pruebas
Ahora veamos los resultados. Podemos observar que el algoritmo basado en el método de gradiente con un efecto de enjambre incorporado aborda las tareas mejor que los métodos de gradiente convencionales.
=============================
5 Hilly's; Func runs: 10000; result: 0.3422040822277234
25 Hilly's; Func runs: 10000; result: 0.3421751631202356
500 Hilly's; Func runs: 10000; result: 0.3421605659711745
=============================
5 Forest's; Func runs: 10000; result: 0.5708601371368296
25 Forest's; Func runs: 10000; result: 0.34628707444514434
500 Forest's; Func runs: 10000; result: 0.32879379664917996
=============================
5 Megacity's; Func runs: 10000; result: 0,199999999999999998
25 Megacity's; Func runs: 10000; result: 0,20923076923076928
500 Megacity's; Func runs: 10000; result: 0,23076923076922945
=============================
All score: 2.91248 (32.36%)
La visualización muestra una gran dispersión en los resultados para funciones de baja dimensionalidad.
DOS en la función de prueba Hilly
DOS en la función de prueba Forest
DOS en la función de prueba Megacity
La tabla de calificación de los algoritmos de optimización de población DOS se presenta con fines informativos.
| № | AO | Description | Hilly | Hilly Final | Forest | Forest Final | Megacity (discrete) | Megacity Final | Resultado Final | % de 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 optimization 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 | búsqueda de orbitales atómicos 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 | 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 |
| 30 | 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 |
| 31 | 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 |
| 32 | 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 |
| 33 | 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 |
| 34 | 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 |
| 35 | 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 |
| 36 | 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 |
| 37 | 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 |
| 38 | 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 |
| 39 | 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 |
| 40 | 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 |
| 41 | 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 |
| 42 | 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 |
| 43 | 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 |
| 44 | CROm | coral reefs optimization M | 0,78512 | 0,46032 | 0,25958 | 1,50502 | 0,86688 | 0,35297 | 0,16267 | 1,38252 | 0,63231 | 0,26738 | 0,10734 | 1,00703 | 3,895 | 43,27 |
| 45 | 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 |
| DOS | deterministic oscillatory search | 0.34220 | 0.34218 | 0.34216 | 1.02654 | 0.57086 | 0,34629 | 0.32879 | 1,24594 | 0,20000 | 0,20923 | 0,23077 | 0.64000 | 2.912 | 32.36 | |
| RW | neuroboids optimization algorithm 2(joo) | 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 | |
Conclusiones
El algoritmo tiene un número mínimo de parámetros a configurar (tamaño de la población y factor de movimiento), lo cual simplifica su aplicación y reduce el riesgo de mala configuración.
El sistema de pendiente de tres estados (positivo, negativo, desconocido) asegura un comportamiento adaptativo de las partículas dependiendo de la calidad de la dirección de búsqueda actual; esta es la principal innovación presente en el algoritmo. La ausencia de operaciones matemáticas complejas lo hace eficiente desde un punto de vista computacional.
Su principal fortaleza radica en la combinación de la eficiencia de los algoritmos de enjambre con la fiabilidad y reproducibilidad de los métodos deterministas, aunque en general los métodos deterministas son inferiores a los estocásticos. No obstante, para resolver algunos problemas tales métodos están justificados.
Figura 2. Clasificación por colores de los algoritmos según las pruebas respectivas
Figura 3. Histograma de los resultados de las pruebas de algoritmos (en una escala de 0 a 100, cuanto más mejor, donde 100 es el máximo resultado teórico posible, el script para calcular la tabla de puntuación está en el archivo)
Ventajas y desventajas del algoritmo DOS:
Ventajas:
- Es rápido.
- Aplicación muy simple.
Desventajas:
- Dispersión de resultados en funciones de baja dimensionalidad.
Adjuntamos al artículo un archivo con las versiones actuales de los códigos de los algoritmos. El autor de este artículo no se responsabiliza de la exactitud absoluta de la descripción de los algoritmos canónicos, muchos de ellos han sido modificados para mejorar las capacidades de búsqueda. Las conclusiones y juicios presentados en los artículos se basan en los resultados de los experimentos realizados.
Programas usados en el artículo
| # | Nombre | Tipo | Descripción |
|---|---|---|---|
| 1 | #C_AO.mqh | Archivo de inclusión | Clase padre de algoritmos de optimización basados en la población |
| 2 | #C_AO_enum.mqh | Archivo de inclusión | Enumeración de los algoritmos de optimización basados en la población |
| 3 | TestFunctions.mqh | Archivo de inclusión | Biblioteca de funciones de prueba |
| 4 | TestStandFunctions.mqh | Archivo de inclusión | Biblioteca de funciones del banco de pruebas |
| 5 | Utilities.mqh | Archivo de inclusión | Biblioteca de funciones auxiliares |
| 6 | CalculationTestResults.mqh | Archivo de inclusión | Script para calcular los resultados en una tabla comparativa |
| 7 | Testing AOs.mq5 | Script | Banco de pruebas único para todos los algoritmos de optimización basados en la población |
| 8 | Simple use of population optimization algorithms.mq5 | Script | Ejemplo sencillo de utilización de algoritmos de optimización basados en la población sin visualización |
| 9 | Test_AO_DOS.mq5 | Script | Banco de pruebas para DOS |
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/18154
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.
Utilizando redes neuronales en MetaTrader
Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 19): ZigZag Analyzer
Particularidades del trabajo con números del tipo double en MQL4
Redes neuronales en el trading: Generalización de series temporales sin vinculación a datos (Final)
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso