Discusión sobre el artículo "Algoritmos de optimización de la población: Evolución de grupos sociales (Evolution of Social Groups, ESG)"

 

Artículo publicado Algoritmos de optimización de la población: Evolución de grupos sociales (Evolution of Social Groups, ESG):

En este artículo analizaremos el principio de construcción de algoritmos multipoblacionales y como ejemplo de este tipo de algoritmos consideraremos la evolución de grupos sociales (ESG), un nuevo algoritmo de autor. Así, analizaremos los conceptos básicos, los mecanismos de interacción con la población y las ventajas de este algoritmo, y revisaremos su rendimiento en problemas de optimización.

En el campo de la optimización, existe una amplia gama de algoritmos poblacionales diseñados para encontrar soluciones óptimas a diversos problemas. No obstante, a pesar de su importancia, los algoritmos multipoblacionales y de enjambre múltiple no han sido suficientemente tratados hasta ahora en nuestros artículos e investigaciones. En consecuencia, he llegado a la conclusión de que debemos profundizar en este tema tan fascinante y prometedor.

Los algoritmos multipoblacionales se basan en la idea de usar múltiples poblaciones independientes para resolver problemas de optimización. Las poblaciones funcionan lógicamente en paralelo y pueden intercambiar información sobre las soluciones óptimas, lo cual permite explorar simultáneamente distintas regiones del espacio de parámetros y encontrar diferentes óptimos. Por otra parte, los algoritmos de enjambre múltiple utilizan grupos sociales (enjambres) de muchas partículas interactuantes que pueden cooperar entre sí de forma similar e intercambiar información para alcanzar soluciones óptimas.

En el presente artículo, llenaremos ese vacío y analizaremos como ejemplo un algoritmo ESG multipoblacional que hemos creado específicamente para esta ocasión. Asimismo, repasaremos los principios básicos de estos algoritmos, y revisaremos los resultados de los estudios comparativos para evaluar el rendimiento de dichos algoritmos en comparación con los métodos de optimización monopoblacionales.

Autor: Andrey Dik

 
34: OPTIMIZATION_METHOD_AO_HS = 1 e-323
33: OPTIMIZATION_METHOD_AO_GSA = 0.11926002964619356
32: OPTIMIZATION_METHOD_AO_ABC = 0.4042085745674859
31: OPTIMIZATION_METHOD_AO_MA = 0.612338549995716
30: OPTIMIZATION_METHOD_AO_BFO = 0.6679763921514072
29: OPTIMIZATION_METHOD_AO_BFO_GA = 0.71308437578657
28: OPTIMIZATION_METHOD_AO_CSS = 0.7316626048819873
27: OPTIMIZATION_METHOD_AO_FSS = 0.7355579934372427
26: OPTIMIZATION_METHOD_AO_GWO = 0.7390576242470235
25: OPTIMIZATION_METHOD_AO_RND = 0.8155449913938271
24: OPTIMIZATION_METHOD_AO_PSO = 0.8222303819859975
23: OPTIMIZATION_METHOD_AO_SC = 0.8340939685401099
22: OPTIMIZATION_METHOD_AO_BA = 0.845763320077643
21: OPTIMIZATION_METHOD_AO_Micro_AIS = 0.8528065344750899
20: OPTIMIZATION_METHOD_AO_SA = 0.8589854552563216
19: OPTIMIZATION_METHOD_AO_SFL = 0.8597046576708655
18: OPTIMIZATION_METHOD_AO_IWDm = 0.862259472275573
17: OPTIMIZATION_METHOD_AO_EM = 0.8779833807818905
16: OPTIMIZATION_METHOD_AO_SDS = 0.9027267066161594
15: OPTIMIZATION_METHOD_AO_NMm = 0.9076903894257041
14: OPTIMIZATION_METHOD_AO_FAm = 0.9111364322206529
13: OPTIMIZATION_METHOD_AO_ESG = 0.9128694208149278
12: OPTIMIZATION_METHOD_AO_SDOm = 0.9182612507465655
11: OPTIMIZATION_METHOD_AO_COAm = 0.9198698363722636
10: OPTIMIZATION_METHOD_AO_IWO = 0.923914294524697
09: OPTIMIZATION_METHOD_AO_SSG = 0.9304990658351672
08: OPTIMIZATION_METHOD_AO_BGA = 0.9389284935189659
07: OPTIMIZATION_METHOD_AO_ACOm = 0.944545536542497
06: OPTIMIZATION_METHOD_AO_DE = 0.9482478998933197
05: OPTIMIZATION_METHOD_AO_POES = 0.9528516011673952
04: OPTIMIZATION_METHOD_AO_SIA = 0.9540996483364099
03: OPTIMIZATION_METHOD_AO_MEC = 0.9574730447145243
02: OPTIMIZATION_METHOD_AO_SDSm = 0.9648638811101882
01: OPTIMIZATION_METHOD_PSO = 0.9653160312454183
00: OPTIMIZATION_METHOD_AO_P_O_ES = 0.9654152361899765
 
34: OPTIMIZATION_METHOD_AO_ABC = 0.42453133581346014
33: OPTIMIZATION_METHOD_AO_IWDm = 0.48360991828383987
32: OPTIMIZATION_METHOD_AO_SIA = 0.49114081735004017
31: OPTIMIZATION_METHOD_AO_EM = 0.49479704987697276
30: OPTIMIZATION_METHOD_AO_RND = 0.5085913649249508
29: OPTIMIZATION_METHOD_AO_MA = 0.5129110822292692
28: OPTIMIZATION_METHOD_AO_HS = 0.5129110822292692
27: OPTIMIZATION_METHOD_AO_CSS = 0.5138134842496185
26: OPTIMIZATION_METHOD_AO_SSG = 0.518468314742929
25: OPTIMIZATION_METHOD_AO_SC = 0.5243709181146918
24: OPTIMIZATION_METHOD_AO_SA = 0.532630712905892
23: OPTIMIZATION_METHOD_AO_FSS = 0.5405996550405998
22: OPTIMIZATION_METHOD_AO_PSO = 0.5430691869913079
21: OPTIMIZATION_METHOD_AO_FAm = 0.5629971666466362
20: OPTIMIZATION_METHOD_AO_BA = 0.5653828707497576
19: OPTIMIZATION_METHOD_AO_BFO = 0.5708620661833331
18: OPTIMIZATION_METHOD_AO_IWO = 0.5736967768562664
17: OPTIMIZATION_METHOD_AO_NMm = 0.5818790406200212
16: OPTIMIZATION_METHOD_AO_ESG = 0.5945790493029925
15: OPTIMIZATION_METHOD_AO_GWO = 0.6234871646160723
14: OPTIMIZATION_METHOD_PSO = 0.6256882439878475
13: OPTIMIZATION_METHOD_AO_GSA = 0.6735183680285166
12: OPTIMIZATION_METHOD_AO_SFL = 0.6885524892005978
11: OPTIMIZATION_METHOD_AO_DE = 0.7092034045816206
10: OPTIMIZATION_METHOD_AO_COAm = 0.7263185318109061
09: OPTIMIZATION_METHOD_AO_SDS = 0.7686064552778226
08: OPTIMIZATION_METHOD_AO_Micro_AIS = 0.7722431882203732
07: OPTIMIZATION_METHOD_AO_SDOm = 0.7808430850753312
06: OPTIMIZATION_METHOD_AO_MEC = 0.7816647439743983
05: OPTIMIZATION_METHOD_AO_ACOm = 0.7830252357918316
04: OPTIMIZATION_METHOD_AO_POES = 0.8453008986622238
03: OPTIMIZATION_METHOD_AO_P_O_ES = 0.8523920887258357
02: OPTIMIZATION_METHOD_AO_SDSm = 0.9046058644799349
01: OPTIMIZATION_METHOD_AO_BGA = 0.9856063511804057
00: OPTIMIZATION_METHOD_AO_BFO_GA = 0.9880292622094636
 
fxsaber #:

¿cuántas ejecuciones de ff y cuántas veces se ha realizado la prueba? ¿se trata de promedios?
 
Andrey Dik #:

¿cuántas ejecuciones de ff y cuántas veces se ha realizado la prueba? ¿se trata de promedios?

¿Por qué se toma el resultado medio y no el más alto?

    aveResult += AO.fB;
  }

  aveResult /=(double)NumberRepetTest_P;
 
fxsaber #:

¿Por qué tomar el resultado medio y no el más alto?

Porque el mayor resultado no está garantizado. Le diré más, ningún resultado está garantizado en la búsqueda estocástica.

Sólo se puede estimar el resultado medio para un cierto número de pruebas, en los artículos que tomamos 10 pruebas, es suficiente para una buena evaluación de la comparación de algos entre sí. Es posible aumentar el número de pruebas aún más, por supuesto, por ejemplo 100 o más, pero deja de tener sentido debido a la rápida disminución de la precisión de la medición. En resumen, 10 es lo mejor, antes usaba 5 pruebas - no era suficiente.

Y, algunos algoritmos muestran una gran dispersión en la convergencia, esta es una propiedad muy importante de los algoritmos de optimización - la repetibilidad de los resultados, que caracteriza la estabilidad del modelo probabilístico del algoritmo (a menos que, por supuesto, estemos hablando de estrategias de búsqueda determinista, los resultados de los cuales serán invariablemente los mismos, pero, por regla general, tales algoritmos tienen baja convergencia).

En general, es necesario hacer al menos 10 pruebas para poder comparar adecuadamente algoritmos que tienen en su base la naturaleza estocástica de la estrategia de búsqueda.

De forma muy aproximada podemos hacer una analogía: ¿cuál de las estrategias de clavar una lanza en un pajar es más eficaz para encontrar una manzana entre un montón de paja? La comparación sólo puede hacerse en varias pruebas, de lo contrario existe una probabilidad no nula de acertar a la manzana con la lanza la primera vez si se pincha estrictamente desde la parte superior del montón en el centro, y es erróneo pensar que éste es un resultado natural de tal estrategia.

Además, las estrategias se dan en forma absolutamente pura, puede decirse que es un elixir de estrategias, no enturbiado por la aplicación del cribado de duplicados y otras técnicas de aceleración de la búsqueda para un número limitado de ejecuciones FF. Cada nuevo conjunto de duplicados desperdicia una ejecución, y los algoritmos en esta forma pura son muy fáciles de comparar.

Cuando el espacio de búsqueda es pequeño, la exclusión de duplicados puede suponer una gran diferencia, e incluso los algoritmos más débiles pueden mostrar buenos resultados. Pero a medida que aumenta el espacio de búsqueda, la exclusión por duplicado pierde sentido más rápidamente, y las diferencias en las capacidades de las estrategias de búsqueda se hacen más evidentes.

Puede que haya transmitido mal mi punto de vista con este post, algunas cosas son muy difíciles de explicar, por desgracia.

 
Andrey Dik #:

Sólo es posible estimar el resultado medio de un cierto número de pruebas

Creo que es lógico disponer de un parámetro de entrada "número de repeticiones" para buscar el máximo global. Por ejemplo, optimizamos un TS en el probador estándar. A veces es lógico ejecutar el optimizador varias veces seguidas para reducir la probabilidad de quedarse atascado en extremos locales. Sí, la velocidad de cálculo disminuirá en el número de veces correspondiente, pero la probabilidad de alcanzar un máximo global será mayor.
 
fxsaber #:
Veo lógico tener un parámetro de entrada "número de repeticiones" para buscar el máximo global.


34: OPTIMIZATION_METHOD_AO_HS = -1.7976931348623157 e+308
33: OPTIMIZATION_METHOD_AO_CSS = 0.49720358822818334
32: OPTIMIZATION_METHOD_AO_FSS = 0.5126268634117646
31: OPTIMIZATION_METHOD_AO_MA = 0.5456638212207142
30: OPTIMIZATION_METHOD_AO_SC = 0.5493573778417595
29: OPTIMIZATION_METHOD_AO_SFL = 0.5586288936731915
28: OPTIMIZATION_METHOD_AO_EM = 0.5622069376759021
27: OPTIMIZATION_METHOD_AO_BFO = 0.572272929264936
26: OPTIMIZATION_METHOD_AO_GWO = 0.576823172558009
25: OPTIMIZATION_METHOD_AO_BA = 0.5780620208551676
24: OPTIMIZATION_METHOD_AO_COAm = 0.6122501636921197
23: OPTIMIZATION_METHOD_AO_FAm = 0.6140389813209256
22: OPTIMIZATION_METHOD_AO_IWO = 0.668152749061326
21: OPTIMIZATION_METHOD_AO_RND = 0.6708834560036839
20: OPTIMIZATION_METHOD_AO_SDSm = 0.6949312990837662
19: OPTIMIZATION_METHOD_AO_ESG = 0.6998001260367949
18: OPTIMIZATION_METHOD_AO_DE = 0.7011196053256343
17: OPTIMIZATION_METHOD_AO_IWDm = 0.7021399692041209
16: OPTIMIZATION_METHOD_AO_GSA = 0.7220579685405103
15: OPTIMIZATION_METHOD_AO_PSO = 0.749441828773945
14: OPTIMIZATION_METHOD_AO_SA = 0.7682447940796119
13: OPTIMIZATION_METHOD_AO_MEC = 0.7861990306904714
12: OPTIMIZATION_METHOD_AO_ABC = 0.7907454297118246
11: OPTIMIZATION_METHOD_AO_SDS = 0.8196051951016118
10: OPTIMIZATION_METHOD_AO_SIA = 0.8221393904152611
09: OPTIMIZATION_METHOD_AO_SDOm = 0.8473736964247897
08: OPTIMIZATION_METHOD_PSO = 0.8554905139189528
07: OPTIMIZATION_METHOD_AO_BFO_GA = 0.9302287492114422
06: OPTIMIZATION_METHOD_AO_SSG = 0.9508929176886642
05: OPTIMIZATION_METHOD_AO_Micro_AIS = 0.9744230924005981
04: OPTIMIZATION_METHOD_AO_BGA = 0.9758026556865227
03: OPTIMIZATION_METHOD_AO_ACOm = 0.9842635986445009
02: OPTIMIZATION_METHOD_AO_P_O_ES = 0.9862393247408759
01: OPTIMIZATION_METHOD_AO_POES = 0.9939584765415376
00: OPTIMIZATION_METHOD_AO_NMm = 0.9992316949848764
inAmountCycles = 1000, inRepeats = 5

Repeticiones - el número de llamadas independientes al algoritmo.

CantidadCiclos - el número de llamadas FF en cada intento (ver Repeticiones).

Para cada algoritmo se obtiene el mejor resultado (ver Repeticiones).

 
  MathSrand ((int)GetMicrosecondCount ()); // reinicio del generador

Yo lo haría así.

Sleep(1); // aleatorio GetMicrosecondCount ().
MathSrand ((int)TimeLocal() + (int)GetMicrosecondCount ()); // reinicio del generador

De lo contrario se repite cada vez que se ejecuta el script.

 
fxsaber #:
Creo que es lógico tener un parámetro de entrada "número de repeticiones" para buscar el máximo global. Por ejemplo, optimizamos un TS en el Probador estándar. A veces es lógico ejecutar el optimizador varias veces seguidas para reducir la probabilidad de quedarse atascado en extremos locales. Sí, la velocidad de los cálculos disminuirá en el número correspondiente de veces, pero la probabilidad de llegar a un extremo global será mayor.
fxsaber #:


Repeticiones - número de llamadas independientes del algoritmo.

CantidadCiclos - número de llamadas FF en cada intento (ver Repeticiones).

Para cada algoritmo se muestra el mejor resultado (ver Repeticiones).

Sí, para aumentar la probabilidad de encontrar un global, en igualdad de condiciones, basta con aumentar el número de pruebas y utilizar la mejor solución encontrada. Incluso el algoritmo RND tiene una probabilidad no nula de encontrar lo que necesita con este enfoque.

Pero, como he descrito antes, sólo el resultado medio permite comparar los algoritmos entre sí.

 
fxsaber #:

Lo habría hecho así.

De lo contrario, se repite cada vez que se ejecuta el script.

Dudo que el valor GetMicrosecondCount pueda repetir los valores en repetidas ejecuciones, aunque se esfuerce. Siempre que las pruebas individuales duren más de un microsegundo, claro.