MetaTrader 5 / Probador
English Русский Deutsch 日本語 Português
preview
Algoritmos de optimización de la población: Resiliencia ante el estancamiento en los extremos locales (Parte II)

Algoritmos de optimización de la población: Resiliencia ante el estancamiento en los extremos locales (Parte II)

MetaTrader 5 — Probador | 29 agosto 2024, 16:10
31 0
Andrey Dik
Andrey Dik

Contenido:

1. Discusión sobre los algoritmos
2. Mejoramos el agente BGA
3. Conclusiones


Nuestra investigación se adentrará en el estudio de la robustez de los algoritmos de optimización basados en poblaciones, y su capacidad para superar trampas locales y alcanzar máximos globales en una variedad de funciones de prueba. En el artículo anterior analizamos los algoritmos que ocuparon posiciones modestas en la clasificación, así que ahora es el momento de centrar nuestra atención en los que mostraron un rendimiento excelente en este estudio.

Hoy intentaremos ofrecer un análisis en profundidad de cada uno de estos algoritmos, identificando sus ventajas y características únicas. Nuestro objetivo será comprender qué estrategias y enfoques hacen que estos algoritmos superen con éxito las dificultades y alcancen los objetivos de optimización global.

Esta fase de la investigación no solo nos permitirá comprender mejor la resistencia de los algoritmos poblacionales a quedarse atascados en trampas localizadas, sino también identificar los factores clave que contribuyen a su éxito ante funciones de prueba diversas y complejas. El presente trabajo pretende avanzar en la comprensión de cómo pueden optimizarse y mejorarse estos algoritmos, y también identificar oportunidades para utilizarlos juntos e hibridarlos para resolver con eficacia distintos problemas de optimización en el futuro.


1. Discusión de los algoritmos

Vamos a continuar estudiando los algoritmos que ocupan las primeras posiciones en nuestra tabla comparativa. Estos algoritmos merecen realmente un examen y una atención más detallados. Hoy nos sumergiremos en un análisis detallado de sus características para descubrir todos los aspectos que los hacen tan significativos y eficaces a la hora de resolver problemas complejos de optimización.

A continuación le mostraremos los informes del funcionamiento de los algoritmos:

  • C_AO_FSS:50;0.01;0.8 - nombre del algoritmo y sus parámetros externos
  • 5 Hilly's - nombre de la función de prueba y su número en la misma
  •  Func runs: 10000 - número de inicios
  • result: 0.32457068874346456 - resultado obtenido, donde 0.0 es el mínimo de la función de prueba y 1.0 es el máximo, cuanto mayor sea el valor, mejor.
  • All score: 1,33084 - valor total de los puntos obtenidos, cuanto mayor sea el valor, mejor

Estrategias evolutivas, (P+O)ES

C_AO_(P_O)ES:100:150:0.02:8.0:10
=============================
5 Hilly's; Func runs: 10000; result: 0.45574011563217454
25 Hilly's; Func runs: 10000; result: 0.5979154724556998
500 Hilly's; Func runs: 10000; result: 0.3415203622112476
=============================
5 Forest's; Func runs: 10000; result: 0.18929181937830403
25 Forest's; Func runs: 10000; result: 0.1837517532554242
500 Forest's; Func runs: 10000; result: 0.15411134176683486
=============================
5 Megacity's; Func runs: 10000; result: 0.10153846153846155
25 Megacity's; Func runs: 10000; result: 0.12030769230769231
500 Megacity's; Func runs: 10000; result: 0.08793846153846216
=============================
All score: 2.23212

A diferencia de su homólogo más joven, el (PO)ES, este algoritmo (P+O)ES se muestra muy activo en el espacio de búsqueda; resulta especialmente evidente en la función suave Hilly, donde la población se divide en varios grupos, cada uno explorando diferentes áreas. Sin embargo, en la función Forest suave su eficacia disminuye de alguna manera, y en la función discreta se muestra mal (solo se alcanza la colina más cercana). En general, el algoritmo resulta muy interesante en funciones suaves diferenciables, pero muestra una clara tendencia a quedarse atascado y una falta de capacidad para mejorar los resultados.

Optimización del Lobo Gris, GWO

C_AO_GWO:50;10
=============================
5 Hilly's; Func runs: 10000; result: 0.5385541648909985
25 Hilly's; Func runs: 10000; result: 0.33060651191769963
500 Hilly's; Func runs: 10000; result: 0.25796885816873344
=============================
5 Forest's; Func runs: 10000; result: 0.33256641908450685
25 Forest's; Func runs: 10000; result: 0.2040563379483599
500 Forest's; Func runs: 10000; result: 0.15278428644972566
=============================
5 Megacity's; Func runs: 10000; result: 0.2784615384615384
25 Megacity's; Func runs: 10000; result: 0.1587692307692308
500 Megacity's; Func runs: 10000; result: 0.133153846153847
=============================
All score: 2.38692

La manada de lobos del algoritmo GWO se precipita a través de la vasta extensión del mundo virtual, extendiéndose rápidamente en todas direcciones en varias funciones de prueba. Esta propiedad puede usarse eficazmente en las iteraciones iniciales, especialmente si el algoritmo se combina con otro método que pueda mejorar y complementar las soluciones encontradas. Las magníficas capacidades de exploración de la manada indican su potencial, pero por desgracia la precisión en la identificación de zonas sigue siendo su punto débil. Resulta interesante observar que el algoritmo del lobo gris ha obtenido incluso mejores resultados que la prueba convencional con agentes distribuidos uniformemente.

Algoritmo de salto de rana aleatorio, SFL

C_AO_SFL:50;25;15;5;0.7
=============================
5 Hilly's; Func runs: 10000; result: 0.5009251084703008
25 Hilly's; Func runs: 10000; result: 0.3175649450809088
500 Hilly's; Func runs: 10000; result: 0.25514153268631673
=============================
5 Forest's; Func runs: 10000; result: 0.4165336325557746
25 Forest's; Func runs: 10000; result: 0.21617658684174407
500 Forest's; Func runs: 10000; result: 0.15782134182434096
=============================
5 Megacity's; Func runs: 10000; result: 0.2892307692307692
25 Megacity's; Func runs: 10000; result: 0.14892307692307696
500 Megacity's; Func runs: 10000; result: 0.10636923076923148
=============================
All score: 2.40869

El algoritmo SFL ha demostrado una capacidad de propagación aún mayor en diferentes direcciones del espacio de búsqueda, incluso en la función Megacity discreta, en comparación con el algoritmo anterior de la lista. El SFL es incluso capaz de alcanzar regiones máximas globales en un número determinado de iteraciones. No obstante, la precisión de matización de las soluciones encontradas no es un punto fuerte del SFL. Este algoritmo, similar al GWO, ha logrado mejores resultados que en la prueba convencional.

Algoritmo de búsqueda aleatoria, RND

C_AO_RND:50
=============================
5 Hilly's; Func runs: 10000; result: 0.5024853724464499
25 Hilly's; Func runs: 10000; result: 0.3284469438564529
500 Hilly's; Func runs: 10000; result: 0.2600678718550755
=============================
5 Forest's; Func runs: 10000; result: 0.3989291459162246
25 Forest's; Func runs: 10000; result: 0.22913381881119183
500 Forest's; Func runs: 10000; result: 0.16727444696703453
=============================
5 Megacity's; Func runs: 10000; result: 0.2753846153846154
25 Megacity's; Func runs: 10000; result: 0.14861538461538465
500 Megacity's; Func runs: 10000; result: 0.09890769230769311
=============================
All score: 2.40925

Aquí llegamos al algoritmo RND. Este sencillo método de optimización ha superado a muchos rivales respetados y conocidos en esta competición única. Debemos recordar que la estrategia del algoritmo "RND" tiene una probabilidad del 50%: o bien se elige una coordenada de un individuo seleccionado al azar de la población, o bien se genera una coordenada aleatoria con una distribución uniforme. Sin embargo, esto ha permitido al algoritmo situarse en la mitad de la lista de competidores. Esto se debe a sus amplias posibilidades de exploración espacial, aunque en este caso no resulta necesario hablar de precisión.

Algoritmo de evolución de grupos sociales, ESG

C_AO_ESG:200:100:0.1:2.0:10.0
=============================
5 Hilly's; Func runs: 10000; result: 0.3695915822772909
25 Hilly's; Func runs: 10000; result: 0.3396716009249312
500 Hilly's; Func runs: 10000; result: 0.2727013729189837
=============================
5 Forest's; Func runs: 10000; result: 0.2956316169252261
25 Forest's; Func runs: 10000; result: 0.2875217303660672
500 Forest's; Func runs: 10000; result: 0.16124201361354124
=============================
5 Megacity's; Func runs: 10000; result: 0.30769230769230765
25 Megacity's; Func runs: 10000; result: 0.306153846153846
500 Megacity's; Func runs: 10000; result: 0.13183076923077003
=============================
All score: 2.47204

El algoritmo ESG muestra una buena capacidad de exploración del espacio de búsqueda, dividiendo este en grupos característicos. Sin embargo, debemos señalar que deja fuera partes distantes del espacio, lo cual puede plantear problemas a la hora de explorar toda la escala de la tarea. También muestra indicios de estancamiento en extremos locales significativos, lo que puede dificultar la consecución del óptimo global. A pesar de ello, el algoritmo muestra un éxito considerable con la función Megacity discreta, lo cual pone de relieve su potencial en determinados entornos y tareas.

Algoritmo de gotas de agua inteligentes, IWDm

C_AO_IWDm:50;10;3.0
=============================
5 Hilly's; Func runs: 10000; result: 0.4883273901756646
25 Hilly's; Func runs: 10000; result: 0.34290016593207995
500 Hilly's; Func runs: 10000; result: 0.2581256124908963
=============================
5 Forest's; Func runs: 10000; result: 0.5119191969436073
25 Forest's; Func runs: 10000; result: 0.2564038040639046
500 Forest's; Func runs: 10000; result: 0.1675925588605327
=============================
5 Megacity's; Func runs: 10000; result: 0.34153846153846157
25 Megacity's; Func runs: 10000; result: 0.15784615384615389
500 Megacity's; Func runs: 10000; result: 0.09889230769230851
=============================
All score: 2.62355

Como las corrientes de un río caudaloso, el algoritmo IWDm se desliza rápidamente por el espacio de búsqueda, alcanzando rápidamente la región del máximo global y mostrando una excelente capacidad de búsqueda. No obstante, cabe señalar que este algoritmo carece de cualidades de refinamiento, lo cual puede dificultar la determinación precisa de la solución óptima.

Este algoritmo no se encuentra entre los mejores de la tabla de clasificación habitual, pero en esta prueba en particular ha obtenido unos resultados impresionantes en comparación con otros algoritmos. Podemos recomendar el uso de IWDm en las fases iniciales de la optimización para pasar después a algoritmos más precisos, enriqueciendo y mejorando el proceso global de optimización.

Enjambre de partículas, PSO

C_AO_PSO:50;0.8;0.4;0.4
=============================
5 Hilly's; Func runs: 10000; result: 0.5548169875802522
25 Hilly's; Func runs: 10000; result: 0.3407594364160912
500 Hilly's; Func runs: 10000; result: 0.2525297014321252
=============================
5 Forest's; Func runs: 10000; result: 0.4573903259815636
25 Forest's; Func runs: 10000; result: 0.27561812346057046
500 Forest's; Func runs: 10000; result: 0.19079124396445962
=============================
5 Megacity's; Func runs: 10000; result: 0.3092307692307693
25 Megacity's; Func runs: 10000; result: 0.14923076923076928
500 Megacity's; Func runs: 10000; result: 0.09553846153846236
=============================
All score: 2.62591

El algoritmo PSO nos ha impresionado con su súbito alto rendimiento en este experimento, demostrando una velocidad aún mayor para viajar a territorios inexplorados en comparación con su predecesor, el algoritmo IWDm. Este éxito repentino puede explicarse por el hecho de que las partículas en el PSO tienen una velocidad inicial elegida aleatoriamente en la primera iteración, lo cual les permite abandonar rápidamente la posición inicial. Los pasos iniciales del algoritmo se asemejan a una danza de partículas a través del espacio hasta que hallan su particular armonía. Desafortunadamente, esta armonía no siempre conduce a un óptimo global; la falta de cualidades de refinamiento frena la consecución de una solución ideal.

El uso del PSO, al igual que el uso del IWDm, puede recomendarse para las fases iniciales de la optimización, donde su capacidad para explorar rápidamente el espacio de búsqueda puede resultar clave para descubrir soluciones prometedoras.

Algoritmo de murciélago, BA

C_AO_BA:50;0.0;1.0;0.0;1.5;0.0;1.0;0.3;0.3
=============================
5 Hilly's; Func runs: 10000; result: 0.5127608047854995
25 Hilly's; Func runs: 10000; result: 0.4239882910506281
500 Hilly's; Func runs: 10000; result: 0.3127353914885268
=============================
5 Forest's; Func runs: 10000; result: 0.4355521825589907
25 Forest's; Func runs: 10000; result: 0.29303187383086005
500 Forest's; Func runs: 10000; result: 0.19433130092541523
=============================
5 Megacity's; Func runs: 10000; result: 0.28769230769230764
25 Megacity's; Func runs: 10000; result: 0.16030769230769232
500 Megacity's; Func runs: 10000; result: 0.10907692307692407
=============================
All score: 2.72948

Los murciélagos del algoritmo BA tienen la asombrosa propiedad de hallar rápidamente la región del extremo global, moviéndose instantáneamente en la primera iteración. Pero la fórmula de los impulsos sonoros en este método de búsqueda tiene la propiedad de que los movimientos de los murciélagos se desvanecen rápidamente, aunque visualmente se pueda ver la necesidad de seguir buscando. El BA tiene una posición baja en las clasificaciones normales, pero en esta prueba ocupa una línea en la parte superior de la tabla.

 Optimización de malas hierbas invasoras, IWO

C_AO_IWO:50;12;5;2;0.2;0.01
=============================
5 Hilly's; Func runs: 10000; result: 0.4570149872637351
25 Hilly's; Func runs: 10000; result: 0.4252105325836707
500 Hilly's; Func runs: 10000; result: 0.28299287471456525
=============================
5 Forest's; Func runs: 10000; result: 0.43322917175445896
25 Forest's; Func runs: 10000; result: 0.33438950288190694
500 Forest's; Func runs: 10000; result: 0.18632383795879612
=============================
5 Megacity's; Func runs: 10000; result: 0.3061538461538461
25 Megacity's; Func runs: 10000; result: 0.24369230769230765
500 Megacity's; Func runs: 10000; result: 0.12887692307692397
=============================
All score: 2.79788

El algoritmo de malas hierbas invasoras también obedece a la dependencia de la iteración actual respecto a la tasa de propagación, al igual que el algoritmo del murciélago (BA). Sin embargo, en este caso, los agentes son capaces de explorar el espacio de manera más eficiente y completa, lo cual les permite encontrar soluciones óptimas de forma más rápida y precisa, dadas las características clave de la función y la región del máximo global, en comparación con el BA. No obstante, si la distancia del punto de partida hasta el objetivo es grande, las malas hierbas no alcanzarán la región del máximo global; esto se hace especialmente notable en la función Megacity, es decir, los agentes se quedan atascados en el extremo significativo más cercano.

Colonia artificial de abejas, ABC

C_AO_ABC:50;45;10;0.1;0.4
=============================
5 Hilly's; Func runs: 10000; result: 0.5969246550857782
25 Hilly's; Func runs: 10000; result: 0.3899058056869557
500 Hilly's; Func runs: 10000; result: 0.26574506946962373
=============================
5 Forest's; Func runs: 10000; result: 0.536535405336652
25 Forest's; Func runs: 10000; result: 0.29048311417293887
500 Forest's; Func runs: 10000; result: 0.17322987568991322
=============================
5 Megacity's; Func runs: 10000; result: 0.3307692307692308
25 Megacity's; Func runs: 10000; result: 0.18492307692307694
500 Megacity's; Func runs: 10000; result: 0.11512307692307773
=============================
All score: 2.88364

El interesante comportamiento del algoritmo ABC se manifiesta en su capacidad para dividir la población en enjambres individuales que exploran activamente los extremos locales. Sin embargo, es posible que el algoritmo no tenga suficientes cualidades de refinamiento, lo cual se refleja en su posición en la tabla de clasificación estándar. No obstante, existe potencial para mejorar y utilizar sus capacidades de búsqueda en algoritmos híbridos. Al integrarlo con otros métodos de optimización, podremos mejorar significativamente su capacidad para encontrar los óptimos globales y mejorar su rendimiento general en diversos problemas de optimización.

Algoritmo de Evolución Mental, MEC

C_AO_MEC:50;10;0.4
=============================
5 Hilly's; Func runs: 10000; result: 0.5566946043237988
25 Hilly's; Func runs: 10000; result: 0.430203412538813
500 Hilly's; Func runs: 10000; result: 0.2724348221662864
=============================
5 Forest's; Func runs: 10000; result: 0.4548936450507163
25 Forest's; Func runs: 10000; result: 0.3156014530351309
500 Forest's; Func runs: 10000; result: 0.17625852850331755
=============================
5 Megacity's; Func runs: 10000; result: 0.3415384615384615
25 Megacity's; Func runs: 10000; result: 0.23107692307692304
500 Megacity's; Func runs: 10000; result: 0.1186615384615393
=============================
All score: 2.89736

El algoritmo MEC es asombrosamente rápido, detecta de forma instantánea casi todos los extremos locales significativos e identifica con éxito la región máxima global. A pesar del ligero retraso en los resultados normales de las pruebas, el MEC sigue mostrando una gran estabilidad y eficacia a la hora de encontrar soluciones óptimas.

Algoritmo de optimización de cuco, COAm

C_AO_COAm:100;40;0.6;0.6;0.63
=============================
5 Hilly's; Func runs: 10000; result: 0.600998666320958
25 Hilly's; Func runs: 10000; result: 0.42709404776275245
500 Hilly's; Func runs: 10000; result: 0.26571090745735276
=============================
5 Forest's; Func runs: 10000; result: 0.5533129896276743
25 Forest's; Func runs: 10000; result: 0.30413063297063025
500 Forest's; Func runs: 10000; result: 0.1703031415266755
=============================
5 Megacity's; Func runs: 10000; result: 0.3261538461538461
25 Megacity's; Func runs: 10000; result: 0.2046153846153847
500 Megacity's; Func runs: 10000; result: 0.1112615384615393
=============================
All score: 2.96358

Nuestro rendimiento medio en la tabla de clasificación habitual de COAm muestra una sorprendente velocidad de movimiento en el espacio de búsqueda, saliendo fácilmente del mínimo global. Sin embargo, tiene algunas dificultades y se atasca en extremos locales significativos, lo cual le impide alcanzar un máximo global.

Algoritmos de microsistema inmune artificial, Micro-AIS

C_AO_Micro_AIS:50:1:2:0.3
=============================
5 Hilly's; Func runs: 10000; result: 0.6193671060348247
25 Hilly's; Func runs: 10000; result: 0.4656896752001433
500 Hilly's; Func runs: 10000; result: 0.24995620778886124
=============================
5 Forest's; Func runs: 10000; result: 0.7121901446084455
25 Forest's; Func runs: 10000; result: 0.4254191301238518
500 Forest's; Func runs: 10000; result: 0.211517515004865
=============================
5 Megacity's; Func runs: 10000; result: 0.2676923076923077
25 Megacity's; Func runs: 10000; result: 0.16461538461538466
500 Megacity's; Func runs: 10000; result: 0.10927692307692398
=============================
All score: 3.22572

En el algoritmo Micro-AIS se distingue una nube muy uniforme producida por los antígenos, lo cual confiere al proceso un cierto orden que se asemeja más a la armonía que al caos. A pesar de ello, sus propiedades de refinamiento necesitan algunas mejoras, aunque el algoritmo tiene buenas capacidades de búsqueda. No obstante, también resulta propenso a atascarse en trampas localizadas.

Búsqueda armónica, HS

C_AO_HS:50;0.9;0.1;0.2
=============================
5 Hilly's; Func runs: 10000; result: 0.602082991833691
25 Hilly's; Func runs: 10000; result: 0.5533985889779909
500 Hilly's; Func runs: 10000; result: 0.2820448101527182
=============================
5 Forest's; Func runs: 10000; result: 0.6503798132320532
25 Forest's; Func runs: 10000; result: 0.5104503170911219
500 Forest's; Func runs: 10000; result: 0.19337757947865844
=============================
5 Megacity's; Func runs: 10000; result: 0.30769230769230765
25 Megacity's; Func runs: 10000; result: 0.29538461538461525
500 Megacity's; Func runs: 10000; result: 0.12826153846153937
=============================
All score: 3.52307

En esta formulación del problema, el HS muestra una impresionante capacidad de búsqueda y una gran velocidad de desplazamiento por el espacio en busca de un máximo global. Sin embargo, al encontrar el primer extremo local significativo, se ralentiza debido a su dependencia del número de época actual. No obstante, este inconveniente solo resulta evidente en la función Megacity discreta, mientras que en las funciones Hilly y Forest suaves su capacidad de búsqueda sigue siendo impresionante. En la tabla de clasificación, la búsqueda armónica ocupa las primeras posiciones, habiendo demostrado su eficacia también en esta prueba.

Algoritmo de optimización de la dinámica espiral, SDOm

C_AO_SDOm:100;0.5;4.0;10000.0
=============================
5 Hilly's; Func runs: 10000; result: 0.7132463872323508
25 Hilly's; Func runs: 10000; result: 0.43264564401427485
500 Hilly's; Func runs: 10000; result: 0.25506574720969816
=============================
5 Forest's; Func runs: 10000; result: 0.804287574819851
25 Forest's; Func runs: 10000; result: 0.4249161540200845
500 Forest's; Func runs: 10000; result: 0.2193817986301354
=============================
5 Megacity's; Func runs: 10000; result: 0.4938461538461539
25 Megacity's; Func runs: 10000; result: 0.22030769230769232
500 Megacity's; Func runs: 10000; result: 0.11410769230769328
=============================
All score: 3.67780

A la cabeza de la lista de pruebas nos encontramos de repente el algoritmo SDOm. Este algoritmo, basado en oscilaciones armónicas, se manifiesta de una forma muy inusual y única en este experimento, dejando tras de sí un misterio difícil de resolver. Una bola pendular suspendida de una cuerda puede soltarse repentinamente y precipitarse en caída libre. El comportamiento de un algoritmo tiene muchos aspectos que lo hacen especial, y resulta casi imposible predecir las condiciones que conducen a este comportamiento inesperado. Por eso es difícil recomendarlo para una amplia gama de tareas en su forma actual. Sin embargo, en combinación con otros algoritmos, por ejemplo, si cedemos algunos agentes de la población general al control de SDOm, esto podría ayudarnos a identificar patrones cíclicos en la tarea en cuestión.

Algoritmo híbrido de optimización de forrajeo bacteriano con algoritmo genético, BFO-GA

C_AO_BFO_GA:50;0.01;0.8;50;10.0
=============================
5 Hilly's; Func runs: 10000; result: 0.8233662999080027
25 Hilly's; Func runs: 10000; result: 0.5031148772790799
500 Hilly's; Func runs: 10000; result: 0.27434497581097494
=============================
5 Forest's; Func runs: 10000; result: 0.8611314745481611
25 Forest's; Func runs: 10000; result: 0.45038118646429437
500 Forest's; Func runs: 10000; result: 0.1806538222176609
=============================
5 Megacity's; Func runs: 10000; result: 0.3907692307692308
25 Megacity's; Func runs: 10000; result: 0.272
500 Megacity's; Func runs: 10000; result: 0.11061538461538559
=============================
All score: 3.86638

El algoritmo BFO_GA muestra una asombrosa capacidad para detectar rápidamente la región del máximo global: ya en las iteraciones iniciales varios agentes se acercan a las coordenadas objetivo. Sin embargo, en la función discreta, sus resultados resultan menos impresionantes. Aparentemente, el número limitado de iteraciones en el marco de las pruebas no basta para encontrar el óptimo global al completo. No obstante, debemos señalar que nuestras pruebas se inscriben en un marco estricto en el que evaluamos la capacidad del algoritmo para alcanzar sus objetivos.

Búsqueda por difusión estocástica, SDSm

C_AO_SDSm:100;100;0.05
=============================
5 Hilly's; Func runs: 10000; result: 0.6838494804548411
25 Hilly's; Func runs: 10000; result: 0.6796828568841194
500 Hilly's; Func runs: 10000; result: 0.32584905164208583
=============================
5 Forest's; Func runs: 10000; result: 0.6703019775594297
25 Forest's; Func runs: 10000; result: 0.6398441335988195
500 Forest's; Func runs: 10000; result: 0.24899123954861618
=============================
5 Megacity's; Func runs: 10000; result: 0.5307692307692308
25 Megacity's; Func runs: 10000; result: 0.49446153846153845
500 Megacity's; Func runs: 10000; result: 0.14973846153846293
=============================
All score: 4.42349

Al hablar del algoritmo SDSm, no resulta del todo apropiado hacer hincapié en la velocidad a la que los agentes se propagan por el espacio de búsqueda, ya que sus coordenadas se fijan dentro de sectores del entorno seleccionados al azar. De hecho, estos agentes se distribuyen instantáneamente por todo el campo de búsqueda ya después de la primera iteración. Este enfoque único produce resultados notables, demostrando la eficacia de la estrategia del algoritmo.

Lo que distingue a SDSm es su capacidad para aprovechar el poder del azar, aumentando la probabilidad de que ningún rincón del espacio de búsqueda quede inexplorado. Dada esta naturaleza estocástica, el algoritmo puede abarcar eficazmente áreas enormes y revelar información valiosa sobre la superficie de características, lo que lo convierte en una herramienta realmente potente para la resolución de problemas.

Algoritmo genético binario, BGA

C_AO_BGA:50:50:1.0:3:0.001:0.7:3
=============================
5 Hilly's; Func runs: 10000; result: 1.0
25 Hilly's; Func runs: 10000; result: 1.0
500 Hilly's; Func runs: 10000; result: 0.8703352617259978
=============================
5 Forest's; Func runs: 10000; result: 0.8872607468925364
25 Forest's; Func runs: 10000; result: 0.8177419261242314
500 Forest's; Func runs: 10000; result: 0.2603521654104144
=============================
5 Megacity's; Func runs: 10000; result: 0.7492307692307694
25 Megacity's; Func runs: 10000; result: 0.5833846153846155
500 Megacity's; Func runs: 10000; result: 0.24415384615384667
=============================
All score: 6.41246

Los algoritmos genéticos binarios (AGB) aprovechan la mutación genética, lo cual les permite alcanzar instantáneamente cualquier región del espacio de búsqueda sin iteraciones adicionales. Sin embargo, en este escenario de prueba concreto, el BGA sale victorioso a pesar de caer ocasionalmente en la trampa de un óptimo local. En este sentido, el SDSm parece preferible, pues demuestra una mayor capacidad para evitar estas situaciones.

No obstante, debemos reconocer al BGA el mérito de haber obtenido los mejores resultados globales, incluso considerando sus deficiencias. Este logro pone de relieve el potencial del algoritmo y la importancia de encontrar un equilibrio entre exploración y explotación en el proceso de búsqueda. Si profundizamos en la comparación, nos resultará obvio que cada algoritmo tiene sus puntos fuertes y débiles.

En resumen, podemos decir que el BGA muestra unos resultados impresionantes en esta prueba, asegurando su posición de líder.


2. Mejoramos el agente BGA

Para llevar a cabo esta investigación ha sido necesario perfeccionar el código del algoritmo BGA para esta tarea de ensayo concreta. Esta capacidad de colocar agentes en una ubicación aleatoria en el espacio de búsqueda puede resultar muy útil cuando se necesita iniciar la optimización a partir de conjuntos definidos por el usuario.

En el BGA, las soluciones al problema se representan como un código binario, por lo que colocar los agentes de la población en las coordenadas dadas requerirá convertir los valores de las coordenadas de una representación real a una binaria, en este caso al código binario de Gray.

Asimismo, añadiremos un método "DoubleToGene" a las descripciones de los agentes, que convertirá un valor de tipo "double" en una representación genética en el array "genes". Los pasos básicos en el funcionamiento de este método son:

  • Si el número introducido es inferior al valor mínimo permitido, la función creará un array de ceros (el número real "0,0" en la representación del código de Gray) para garantizar que el valor se mantenga dentro del intervalo permitido.
  • Si el número de entrada supera el valor máximo permitido, la función creará un array que copiará los valores del array original que contiene (el número máximo permitido en la codificación de Gray, este número se guarda para casos similares en los que resulta necesario volver al rango si se sale del mismo).
  • Si el número se encuentra dentro del rango válido, se escalará y se convertirá al código Gray. A continuación, este valor se almacenará en un array para su uso en la representación genética.

Así, el método "DoubleToGene" realiza la conversión de un valor real a una representación genética y lo escribe en el correspondiente array de "genes". La función trata los casos en los que el valor de entrada queda fuera del rango válido inicializando o copiando determinados arrays y finalizando la ejecución antes de tiempo. En caso contrario, la función escalará el valor, convertirá las partes enteras y fraccionarias al código Gray y las combinará en una representación genética final.

Código del agente BGA corregido:

//——————————————————————————————————————————————————————————————————————————————
struct S_Agent
{
  void Init (const int coords, const double &min [], const double &max [], int doubleDigitsInChromo)
  {
    ArrayResize(c, coords);
    f = -DBL_MAX;

    ArrayResize(genes, coords);
    ArrayResize(chromosome, 0, 1000);

    for(int i = 0; i < coords; i++)
    {
      genes [i].Init(min [i], max [i], doubleDigitsInChromo);
      ArrayCopy(chromosome, genes [i].gene, ArraySize(chromosome), 0, WHOLE_ARRAY);
    }
  }

  void ExtractGenes ()
  {
    uint pos = 0;

    for (int i = 0; i < ArraySize (genes); i++)
    {
      c [i] = genes [i].ToDouble (chromosome, pos);
      pos  += genes [i].length;

    }
  }

  void DoubleToGene (const double val, const int genePos)
  {
    double value = val;

    //--------------------------------------------------------------------------
    if (value < genes [genePos].rangeMin)
    {
      ArrayInitialize(genes [genePos].gene, 0);
      ArrayCopy (chromosome, genes [genePos].gene, genePos * genes [genePos].length, 0, WHOLE_ARRAY);
      return;
    }

    //--------------------------------------------------------------------------
    else
    {
      if (value > genes [genePos].rangeMax)
      {
        ArrayCopy (chromosome, genes [genePos].geneMax, genePos * genes [genePos].length, 0, WHOLE_ARRAY);
        return;
      }
    }

    //--------------------------------------------------------------------------
    value = Scale(value, genes [genePos].rangeMin, genes [genePos].rangeMax, 0.0, genes [genePos].maxCodedDistance);

    DecimalToGray ((ulong)value, genes [genePos].integPart);

    value = value - (int)value;

    value *= genes [genePos].digitsPowered;

    DecimalToGray ((ulong)value, genes [genePos].fractPart);

    ArrayInitialize(genes [genePos].gene, 0);

    uint   integGrayDigits = genes [genePos].integGrayDigits;
    uint   fractGrayDigits = genes [genePos].fractGrayDigits;
    uint   digits = ArraySize (genes [genePos].integPart);

    if (digits > 0) ArrayCopy (genes [genePos].gene, genes [genePos].integPart, integGrayDigits - digits, 0, WHOLE_ARRAY);

    digits = ArraySize (genes [genePos].fractPart);

    if (digits > 0) ArrayCopy (genes [genePos].gene, genes [genePos].fractPart, genes [genePos].length - digits, 0, WHOLE_ARRAY);

    ArrayCopy (chromosome, genes [genePos].gene, genePos * genes [genePos].length, 0, WHOLE_ARRAY);
  }

  void InjectGeneToChromosome ()
  {

  }

  //----------------------------------------------------------------------------
  double Scale (double In, double InMIN, double InMAX, double OutMIN, double OutMAX)
  {
    if (OutMIN == OutMAX) return (OutMIN);
    if (InMIN == InMAX) return (double((OutMIN + OutMAX) / 2.0));
    else
    {
      if (In < InMIN) return OutMIN;
      if (In > InMAX) return OutMAX;

      return (((In - InMIN) * (OutMAX - OutMIN) / (InMAX - InMIN)) + OutMIN);
    }
  }

  double c [];           //coordinates
  double f;              //fitness

  S_BinaryGene genes []; //there are as many genes as there are coordinates
  char chromosome    [];
};
//——————————————————————————————————————————————————————————————————————————————


3. Conclusiones

Resumen de los resultados del estudio comparativo a gran escala de algoritmos de población, consistente en abandonar el mínimo global y superar todos los obstáculos para alcanzar el máximo global.
Empezaremos por visualizar el rendimiento del comportamiento más interesante de los algoritmos a medida que los probamos.

POES

(PO)ES en Megacity

SDOm

SDOm en Megacity

BFO_GA

BFO_GA en Megacity

SDSm

SDSm en Megacity

BGA

BGA en Megacity

A continuación le presentamos la tabla comparativa final, que muestra el rendimiento detallado de cada algoritmo en las funciones de prueba.

Tab

Figura 1. Gradación por colores de los algoritmos según sus respectivas pruebas. Los resultados superiores o iguales a 0,99 aparecen resaltados en blanco.

Chart

Figura 2. Histograma con los resultados de las pruebas de los algoritmos (en una escala de 0 a 100, cuanto mayor, mejor),

donde 100 es el máximo resultado teórico posible; hay un script para calcular la tabla de puntuación en el archivo).

Para finalizar, debemos destacar específicamente que todas las conclusiones y juicios sobre cada algoritmo se han realizado únicamente en el ámbito del experimento realizado.

De toda la discusión y el análisis del comportamiento de los algoritmos de optimización basados en poblaciones se desprende una conclusión importante: el éxito de los algoritmos depende en gran medida de sus condiciones iniciales de aplicación. Para algunos métodos, como DE, EM, GSA, ACOm, las pruebas desde el punto de vista del mínimo de la función de prueba pueden resultar tan complejas que dificultan la puesta en marcha. Al mismo tiempo, para otros como (P+O)ES, ESG (que originalmente encabezaban la clasificación pero se han convertido ahora en outsiders), el rendimiento cae drásticamente. Por el contrario, para algoritmos como PSO, GWO, SFL, BA, ABC, unas coordenadas iniciales específicamente elegidas pueden mejorar significativamente los resultados. Algunos algoritmos, como BFO-GA, SDOm, han mostrado incluso un rendimiento sobresaliente con este enfoque, superando a la inicialización uniforme aleatoria de agentes.

También debemos señalar que otros algoritmos como IWO, HS, SDSm y BGA han mostrado una robustez universal con poca dependencia de la posición inicial de los agentes. Este experimento en concreto ha puesto de manifiesto que, aunque algunos algoritmos han obtenido malos resultados durante las pruebas, siguen mostrando capacidades impresionantes en determinados momentos del experimento. Algunos han logrado explorar el espacio al principio del proceso, mientras que otros han conseguido mejorar significativamente en fases posteriores. Estas características únicas de cada algoritmo pueden combinarse e hibridarse con éxito, potenciando sus aspectos positivos y reduciendo sus desventajas, lo cual en última instancia puede llevarnos a métodos de optimización más eficaces.

Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/14212

Archivos adjuntos |
Descargar ZIP
The_world_of_AO_Resistance.zip (256.22 KB)
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores
Utilizando redes neuronales en MetaTrader Utilizando redes neuronales en MetaTrader
En el artículo se muestra la aplicación de las redes neuronales en los programas de MQL, usando la biblioteca de libre difusión FANN. Usando como ejemplo una estrategia que utiliza el indicador MACD se ha construido un experto que usa el filtrado con red neuronal de las operaciones. Dicho filtrado ha mejorado las características del sistema comercial.
Redes neuronales: así de sencillo (Parte 79): Adición de solicitudes en el contexto de estado (FAQ) Redes neuronales: así de sencillo (Parte 79): Adición de solicitudes en el contexto de estado (FAQ)
En el artículo anterior, nos familiarizamos con uno de los métodos para detectar objetos en una imagen. Sin embargo, el procesamiento de una imagen estática se diferencia ligeramente del trabajo con series temporales dinámicas que incluyen la dinámica de los precios que hemos analizado. En este artículo les presentaré un método de detección de objetos en vídeo que resulta algo más cercano al problema que estamos resolviendo.
Particularidades del trabajo con números del tipo double en MQL4 Particularidades del trabajo con números del tipo double en MQL4
En estos apuntes hemos reunido consejos para resolver los errores más frecuentes al trabajar con números del tipo double en los programas en MQL4.
Practicando el desarrollo de estrategias de trading Practicando el desarrollo de estrategias de trading
En este artículo, intentaremos desarrollar nuestra propia estrategia de trading. Toda estrategia de trading debe basarse en algún tipo de ventaja estadística. Además, esta ventaja debería existir durante mucho tiempo.