Algoritmo del restaurador de éxito — Successful Restaurateur Algorithm (SRA)
243
0
Contenido
Introducción
Siempre me han fascinado los paralelismos entre los problemas de optimización y los escenarios de la vida real. Mientras exploraba nuevos enfoques de algoritmos metaheurísticos, descubrí similitudes entre la optimización basada en poblaciones y la evolución del negocio de la restauración, y esta idea se convirtió en la inspiración de lo que yo llamo el algoritmo del restaurador de éxito (SRA).
Imagínese al dueño de un restaurante que se esfuerza constantemente por mejorar su menú para aumentar la popularidad de su restaurante y atraer a nuevos clientes. En lugar de abandonar por completo los platos impopulares, adopta un enfoque más sutil: identifica el elemento menos popular y luego lo mezcla cuidadosamente con elementos de los platos de más éxito. A veces se introducen cambios conservadores y otras veces se añaden ingredientes nuevos y atrevidos. El objetivo es siempre el mismo: convertir la oferta más floja en algo que pueda convertirse en un nuevo favorito del menú para sus clientes.
Esta metáfora culinaria constituye la base de la SRA. A diferencia de los algoritmos evolutivos tradicionales, que suelen descartar por completo las soluciones fallidas, la SRA se centra en rehabilitar las soluciones con peor rendimiento combinándolas con elementos exitosos. Este enfoque preserva la diversidad en el espacio de soluciones al tiempo que mejora la calidad general de la población de forma constante.
En este artículo, veremos los mecanismos básicos del SRA, analizaremos su implementación y cómo parámetros como la "temperatura" y la "intensidad de los experimentos de cocción" gestionan el equilibrio entre explotación y exploración; asimismo, compartiremos los resultados de las pruebas comparando el SRA con otros algoritmos conocidos en una tabla de clasificación sobre diferentes funciones de prueba.
Lo que empezó como un experimento creativo se ha convertido en un enfoque prometedor con unas características únicas. Le invito a explorar cómo este algoritmo, inspirado en el negocio de la restauración, ofrece soluciones de optimización con un sabor único y especial.
Implementación del algoritmo
Vamos a analizar el funcionamiento del algoritmo usando analogías sencillas. Imagine que tengo un restaurante. Mi menú tiene diferentes platos y me doy cuenta de que algunos son muy populares y otros apenas los piden los clientes. ¿Qué es lo que hago entonces? No elimino directamente los platos impopulares del menú (reduciendo así la lista de platos disponibles), sino que tomo el plato más impopular e intento mejorarlo. ¿Cómo? Me fijo en los éxitos del restaurante y tomo prestadas algunas ideas o ingredientes. Por ejemplo, tengo un plato de pescado que no se vende bien, pero la ensalada es muy popular. Así que tomo elementos de una ensalada popular (quizá un aliño especial o una forma de servirla) y los aplico a un plato de pescado. Es algo nuevo.
A veces hago pequeños cambios y en otras ocasiones me atrevo a experimentar con audacia. Al principio, cuando abrí el restaurante, experimentaba más, pero ahora que ya he encontrado algunos platos realmente exitosos, hago ajustes más finos en la composición de los ingredientes y sus cantidades. Con el tiempo, incluso los platos más flojos de mi menú han mejorado. Y a veces ocurre que lo que antes era un plato extraño se convierte en un nuevo éxito después de retocarlo. Así, la popularidad general del restaurante crece debido a que todos los platos del menú son populares.
Así funciona también mi algoritmo: no desechamos las soluciones malas, sino que las mejoramos continuamente usando ideas de soluciones mejores. Y cuanto más nos alejamos, menos experimentamos y más refinamos lo que ya hemos encontrado. La figura 1 muestra el esquema del algoritmo.
Figura 1. Esquema del algoritmo SRA
El esquema comienza con el bloque "Inicialización", donde se crea el menú inicial. A continuación se inicia el ciclo principal del algoritmo, que se centra en el menú actual del restaurante ordenado según la calidad del plato. Este menú se representa como un gradiente de colores que va del verde (mejores platos) al rojo (peores platos). Luego siguen cuatro pasos secuenciales: primero, se seleccionan los platos a mejorar, donde el peor plato y el mejor donante se toman con una probabilidad mayor respecto a la ley cuadrática; segundo, se crean nuevas variantes combinando recetas y cambiando ingredientes (y cuanto más alta sea la temperatura, más atrevidos serán los experimentos); tercero, se evalúan los nuevos platos mediante el cálculo de la función de aptitud; y cuarto, se disminuye la temperatura para reducir la radicalidad de los experimentos. La flecha discontinua de la izquierda muestra que el proceso se repite hasta que se alcance la convergencia o se cumpla el criterio de parada. Las designaciones figuran a la derecha: A (círculo verde) representa los mejores platos, B (círculo rojo) representa los peores platos. El esquema al completo visualiza un proceso que se asemeja al trabajo de un restaurador que mejora sistemáticamente los puntos débiles de su menú utilizando elementos de platos de éxito.
Vamos a escribir el pseudocódigo del algoritmo SRA.
// Inicialización
Creamos una población de agentes popSize (platos en el menú)
Para cada agente:
Inicializamos aleatoriamente todas las coordenadas dentro de límites aceptables
Establecemos una temperatura inicial = 1,0
Establecemos un factor de refrigeración = 0,98
Establecemos una intensidad de los experimentos de cocina = 0,3
// Ciclo principal del algoritmo
ANTES de que se cumpla la condición de parada:
// Paso 1: Evaluamos todos los agentes
Para cada agente:
Calculamos el valor de la función de aptitud
// Combinamos las poblaciones actual y anterior
Generamos un menú común a partir de los agentes actuales y anteriores
Ordenamos el menú general según el valor de la función de aptitud de mejor a peor
// Paso 2: Creamos nuevas opciones
Para cada agente de la nueva población:
// Tomamos el peor elemento de la primera mitad de la población ordenada
Copiamos coordenadas del agente con índice (popSize-1)
// Elección entre mejora y experimentación
Si (número aleatorio < (1,0 - menuInnovationRate * temperatura)):
// Seleccionamos el "donante" utilizando el método de la ruleta cuadrática
r = número aleatorio entre 0 y 1
r = r²
donorIndex = escalamos r de 0 a (popSize-1)
// Para cada coordenada
Para cada coordenada c:
// Con probabilidad 0.8 tomamos la coordenada del donante
Si (número aleatorio < 0,8):
agente_actual.c = donante.c
// Mutación adaptativa
mutationRate = 0.1 + 0.4 * temperatura * (index_agent / popSize)
Si (número aleatorio < mutationRate):
// Seleccionamos el tipo de mutación
Si (número aleatorio < 0,5):
agente_actual.c = distribución gaussiana(agente_actual.c)
De lo contrario:
agente_actual.c = valor aleatorio en el rango
// Verificamos que el valor esté dentro de los límites aceptables
agente_actual.c = redondeamos al valor válido más próximo
De lo contrario:
// Creación de un nuevo "plato"
Para cada coordenada c:
Si (número aleatorio < 0,7):
agente_actual.c = valor aleatorio en el rango
De lo contrario:
agente_actual.c = distribución gaussiana(mejor_resolución.c)
// Verificamos que el valor esté dentro de los límites aceptables
agente_actual.c = redondeamos al valor válido más próximo
// Elitismo: a veces basta con añadir elementos de una solución mejor
Si (número aleatorio < 0,1):
numEliteCoords = número aleatorio de 1 a (coords * 0,3)
Para i desde 1 hasta numEliteCoords:
c = índice de coordenadas aleatorias
agente_actual.c = mejor_solucion.c
// Paso 3: Actualizamos la mejor solución
Para cada agente:
Si agente.fitness > mejor_resolucion.fitness:
mejor_solucion = agente
// Paso 4: Disminución de la temperatura
temperatura = temperatura * coeficiente de refrigeración
Si la temperatura < 0,1:
temperatura = 0,1
Devolvemos solución_mejor
Ahora podemos empezar a escribir el código del algoritmo. Escribiremos la clase "C_AO_SRA", que heredará de la clase principal "C_AO" e implementaremos el algoritmo SRA. Veámoslo con más detalle.
Constructor y destructor: popSize, temperature, coolingRate, menuInnovationRate — estos parámetros definen las características principales del algoritmo, como el número de agentes y los parámetros de control de búsqueda.
Método SetParams: actualiza los parámetros de la clase usando como base los valores almacenados en el array "params", los parámetros han sido previamente inicializados en el constructor.
Método init: se utiliza para inicializar el algoritmo. Este toma los valores mínimo y máximo, el paso de variación de los parámetros y el número de épocas y prepara el algoritmo para realizar la tarea de búsqueda.
Métodos Moving y Revision: están diseñados para realizar los pasos principales del algoritmo relacionados con el movimiento (o actualización) del estado de los agentes y "Revision", que se encarga de revisar y adaptar los parámetros.
Miembros de la clase:
- temperature — la temperatura actual asociada con el control del estudio y el programa de temperatura del algoritmo.
- coolingRate — velocidad de enfriamiento que se utiliza para controlar la rapidez con la que la temperatura bajará.
- menuInnovationRate — la intensidad de la experimentación culinaria, la medida en que se anima a los agentes a encontrar nuevas soluciones.
- S_AO_Agent menu [] — array de agentes que representa un "menú" en el contexto del algoritmo SRA.
- S_AO_Agent menuT [] — array de agentes usados para almacenar temporalmente opciones de comida.
//—————————————————————————————————————————————————————————————————————————————— class C_AO_SRA : public C_AO { public: //-------------------------------------------------------------------- ~C_AO_SRA () { } C_AO_SRA () { ao_name = "SRA"; ao_desc = "Successful Restaurateur Algorithm (joo)"; ao_link = "https://www.mql5.com/es/articles/17380"; popSize = 50; // number of agents (size of the "menu") temperature = 1.0; // initial "temperature" for research control coolingRate = 0.98; // cooling rate menuInnovationRate = 0.3; // intensity of culinary experiments ArrayResize (params, 4); params [0].name = "popSize"; params [0].val = popSize; params [1].name = "temperature"; params [1].val = temperature; params [2].name = "coolingRate"; params [2].val = coolingRate; params [3].name = "menuInnovationRate"; params [3].val = menuInnovationRate; } void SetParams () { popSize = (int)params [0].val; temperature = params [1].val; coolingRate = params [2].val; menuInnovationRate = params [3].val; } bool Init (const double &rangeMinP [], // minimum values const double &rangeMaxP [], // maximum values const double &rangeStepP [], // step change const int epochsP = 0); // number of epochs void Moving (); void Revision (); //---------------------------------------------------------------------------- double temperature; // current "temperature" double coolingRate; // cooling rate double menuInnovationRate; // intensity of culinary experiments private: //------------------------------------------------------------------- S_AO_Agent menu []; S_AO_Agent menuT []; }; //——————————————————————————————————————————————————————————————————————————————
El método "Init" de la clase "C_AO_SRA" ejecuta la inicialización del algoritmo:
Comprobación de inicialización: el método llama a "StandardInit" con los valores mínimo y máximo de rangos y pasos, si no tiene éxito, se devuelve "false".
Inicialización de arrays:
- Distribuye el tamaño de los arrays "menu" y "menuT" en función del número de agentes.
- Inicializa cada agente del array "menú".
Restablecer temperatura: establece el valor inicial de "temperatura" en "1,0".
Finalización con éxito: retorna "true" si la inicialización se ha realizado correctamente.
//—————————————————————————————————————————————————————————————————————————————— //--- Initialization bool C_AO_SRA::Init (const double &rangeMinP [], const double &rangeMaxP [], const double &rangeStepP [], const int epochsP = 0) { if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; //---------------------------------------------------------------------------- ArrayResize (menu, popSize * 2); ArrayResize (menuT, popSize * 2); for (int p = 0; p < popSize * 2; p++) menu [p].Init (coords); temperature = 1.0; // reset temperature during initialization return true; } //——————————————————————————————————————————————————————————————————————————————
El método "Moving" de la clase "C_AO_SRA" implementa el paso principal del algoritmo. Consta de dos partes principales: la inicialización de los agentes y su adaptación mediante mutación y creación de nuevas soluciones.
Inicialización primaria (si "revision" es "false"):- Cada agente se inicializa con valores aleatorios dentro de rangos especificados (rangeMin, rangeMax) usando los pasos (rangeStep). Los valores se almacenan en "c" y "cB" para cada agente.
- Se establece "revision" en "true" y el método finaliza la ejecución.
Reducción de la temperatura: la temperatura se multiplica por la coolingRate, que afecta a la probabilidad de que se produzcan más cambios.
Ciclo básico sobre los agentes: para cada agente, se selecciona el peor elemento de la primera mitad de la población ordenada (del array del menú).
Clasificación de las acciones: con cierta probabilidad, que depende de la temperatura, el agente o bien:
- modifica la solución actual (utilizando una "receta donante" de un plato mejor) aplicando una mutación con probabilidad variable.
- crea una nueva solución (valores aleatorios).
Elitismo: con una cierta probabilidad, los elementos de la mejor solución encontrada pueden añadirse a la nueva solución.
//—————————————————————————————————————————————————————————————————————————————— //--- The main step of the algorithm void C_AO_SRA::Moving () { //---------------------------------------------------------------------------- // Initial initialization if (!revision) { for (int p = 0; p < popSize; p++) { for (int c = 0; c < coords; c++) { a [p].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); a [p].c [c] = u.SeInDiSp (a [p].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); a [p].cB [c] = a [p].c [c]; } } revision = true; return; } //---------------------------------------------------------------------------- // Lower the temperature temperature *= coolingRate; // Main loop on population agents for (int p = 0; p < popSize; p++) { // Take the worst element from the first half of the sorted population (with index popSize-1) // Remember that items are sorted from best to worst in the menu ArrayCopy (a [p].c, menu [popSize - 1].c, 0, 0, WHOLE_ARRAY); // Decide whether to create a hybrid or experiment with a new "dish" // The probability of an experiment depends on the temperature - there are more experiments at the beginning if (u.RNDprobab () < (1.0 - menuInnovationRate * temperature)) { // Select a "donor-recipe" with a probability proportional to the success of the dish double r = u.RNDprobab (); r = pow (r, 2); // Increased preference for better dishes int menuIND = (int)u.Scale (r, 0, 1.0, 0, popSize - 1); // The best ones are at the beginning of the array // For each coordinate for (int c = 0; c < coords; c++) { // Take the parameter from a successful dish with the probability depending on the temperature if (u.RNDprobab () < 0.8) { a [p].c [c] = menu [menuIND].c [c]; } // Mutation with adaptive probability - the further from the best solution and the higher the temperature, the more mutations double mutationRate = 0.1 + 0.4 * temperature * (double)(p) / popSize; if (u.RNDprobab () < mutationRate) { // Combination of different types of mutations if (u.RNDprobab () < 0.5) a [p].c [c] = u.GaussDistribution (a [p].c [c], rangeMin [c], rangeMax [c], 2); else a [p].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); // Sometimes a completely new meaning // Make sure the value is within acceptable limits a [p].c [c] = u.SeInDiSp (a [p].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } } } else // Create a completely new "dish" { for (int c = 0; c < coords; c++) { // Variation 1: Completely random value if (u.RNDprobab () < 0.7) { a [p].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]); } // Variation 2: based on the best solution found with a large deviation else { a [p].c [c] = u.GaussDistribution (cB [c], rangeMin [c], rangeMax [c], 1); } a [p].c [c] = u.SeInDiSp (a [p].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); } } // Sometimes we add elements from the best solution directly (elitism) if (u.RNDprobab () < 0.1) { int numEliteCoords = u.RNDintInRange (1, coords / 3); // Take from 1 to 30% of the coordinates for (int i = 0; i < numEliteCoords; i++) { int c = u.RNDminusOne (coords); a [p].c [c] = cB [c]; // Take the value from the best solution } } } } //——————————————————————————————————————————————————————————————————————————————
El método "Revision" de la clase "C_AO_SRA" se encarga de actualizar la mejor solución encontrada y de gestionar el "menú" global de soluciones durante el funcionamiento del algoritmo:
Búsqueda del mejor agente: recorre todos los agentes de la población actual y encuentra el agente con la mejor función de aptitud (f). Si se encuentra un nuevo mejor agente, actualiza el valor "fB" y el índice "bestIND".
Actualización de la mejor solución: si se encuentra el mejor agente (es decir, bestIND no es igual a -1), copia sus parámetros de la solución (c) en la variable cB que representa la mejor solución actual.
Actualización del"menú" común: añade los parámetros actuales de todos los agentes al "menú" común, lo que permite guardar los experimentos realizados.
Clasificación del menú: ordena el array "menú" según la función de aptitud de mejor a peor solución, asegurándose de que las mejores soluciones estén en la primera mitad. Se usará en la siguiente iteración del algoritmo.
Control de la temperatura: establece un umbral inferior para la temperatura, de modo que no descienda por debajo de "0,1", lo cual evita que se produzca una convergencia demasiado rápida.//—————————————————————————————————————————————————————————————————————————————— //--- Update the best solution taking into account greedy selection and the probability of making worse decisions void C_AO_SRA::Revision () { int bestIND = -1; // Find the best agent in the current population for (int p = 0; p < popSize; p++) { if (a [p].f > fB) { fB = a [p].f; bestIND = p; } } // If we find a better solution, update cB if (bestIND != -1) ArrayCopy (cB, a [bestIND].c, 0, 0, WHOLE_ARRAY); // Add the current set of dishes to the general "menu" for (int p = 0; p < popSize; p++) { menu [popSize + p] = a [p]; } // Sort the entire "menu" from best to worst solutions // After sorting, the first half of the menu will contain the best solutions, // which will be used in the next iteration u.Sorting (menu, menuT, popSize * 2); // Prevent the temperature from falling below a certain threshold if (temperature < 0.1) temperature = 0.1; } //——————————————————————————————————————————————————————————————————————————————
Resultados de las pruebas
Ahora podemos ver cómo funciona el algoritmo SRA. A continuación le mostramos una impresión de los resultados de la prueba:
SRA|Successful Restaurateur Algorithm|50.0|1.0|0.98|0.3|
=============================
5 Hilly's; Func runs: 10000; result: 0.9688326305968623
25 Hilly's; Func runs: 10000; result: 0.6345483084017249
500 Hilly's; Func runs: 10000; result: 0.292167027537253
=============================
5 Forest's; Func runs: 10000; result: 0.946368863880973
25 Forest's; Func runs: 10000; result: 0.5550607959254661
500 Forest's; Func runs: 10000; result: 0.19124225531141872
=============================
5 Megacity's; Func runs: 10000; result: 0.7492307692307693
25 Megacity's; Func runs: 10000; result: 0.4403076923076923
500 Megacity's; Func runs: 10000; result: 0.12526153846153956
=============================
All score: 4.90302 (54.48%)
La visualización del rendimiento del algoritmo SRA en el banco de pruebas permite extraer conclusiones sobre los rasgos característicos de la estrategia de búsqueda. En este caso, se observa una amplia exploración del espacio de búsqueda: los agentes se distribuyen uniformemente por todo el espacio, explorando incluso sus rincones más remotos. Al mismo tiempo, no existen signos perceptibles de agrupación en extremos locales, los movimientos de los agentes parecen caóticos.
Noobstante, a pesar de su buena capacidad exploratoria, el algoritmo presenta algunas deficiencias a la hora de refinar las soluciones, como pone de manifiesto su relativamente baja precisión de convergencia. También debemos señalar que existe una pequeña variación en los resultados de las pruebas.
SRA en la función de prueba Hilly
SRA en la función de prueba Forest
SRA en la función de prueba Megacity
Según los resultados de nuestras pruebas, el algoritmo ocupa el puesto 20 en la clasificación de los algoritmos de optimización de la población más potentes. Hasta ahora, se han presentado nueve algoritmos de optimización de autor (joo), entre los que se incluye el nuevo algoritmo SRA.
| # | AO | Description | Hilly | Hilly final | Forest | Forest final | Megacity (discrete) | Megacity final | Final result | % 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 optimization | 0.94629 | 0.66112 | 0.29853 | 1.90593 | 0.87906 | 0.58422 | 0.21146 | 1.67473 | 0.75846 | 0.42646 | 0.12686 | 1.31178 | 4.892 | 54.36 |
| 22 | BIO | blood inheritance optimization (joo) | 0.81568 | 0.65336 | 0.30877 | 1.77781 | 0.89937 | 0.65319 | 0.21760 | 1.77016 | 0.67846 | 0.47631 | 0.13902 | 1.29378 | 4.842 | 53.80 |
| 23 | BSA | bird swarm algorithm | 0.89306 | 0.64900 | 0.26250 | 1.80455 | 0.92420 | 0.71121 | 0.24939 | 1.88479 | 0.69385 | 0.32615 | 0.10012 | 1.12012 | 4.809 | 53.44 |
| 24 | HS | harmony search | 0.86509 | 0.68782 | 0.32527 | 1.87818 | 0.99999 | 0.68002 | 0.09590 | 1.77592 | 0.62000 | 0.42267 | 0.05458 | 1.09725 | 4.751 | 52.79 |
| 25 | SSG | saplings sowing and growing | 0.77839 | 0.64925 | 0.39543 | 1.82308 | 0.85973 | 0.62467 | 0.17429 | 1.65869 | 0.64667 | 0.44133 | 0.10598 | 1.19398 | 4.676 | 51.95 |
| 26 | BCOm | bacterial chemotaxis optimization M | 0.75953 | 0.62268 | 0.31483 | 1.69704 | 0.89378 | 0.61339 | 0.22542 | 1.73259 | 0.65385 | 0.42092 | 0.14435 | 1.21912 | 4.649 | 51.65 |
| 27 | ABO | african buffalo optimization | 0.83337 | 0.62247 | 0.29964 | 1.75548 | 0.92170 | 0.58618 | 0.19723 | 1.70511 | 0.61000 | 0.43154 | 0.13225 | 1.17378 | 4.634 | 51.49 |
| 28 | (PO)ES | (PO) evolution strategies | 0.79025 | 0.62647 | 0.42935 | 1.84606 | 0.87616 | 0.60943 | 0.19591 | 1.68151 | 0.59000 | 0.37933 | 0.11322 | 1.08255 | 4.610 | 51.22 |
| 29 | TSm | tabu search M | 0.87795 | 0.61431 | 0.29104 | 1.78330 | 0.92885 | 0.51844 | 0.19054 | 1.63783 | 0.61077 | 0.38215 | 0.12157 | 1.11449 | 4.536 | 50.40 |
| 30 | BSO | brain storm optimization | 0.93736 | 0.57616 | 0.29688 | 1.81041 | 0.93131 | 0.55866 | 0.23537 | 1.72534 | 0.55231 | 0.29077 | 0.11914 | 0.96222 | 4.498 | 49.98 |
| 31 | WOAm | wale optimization algorithm M | 0.84521 | 0.56298 | 0.26263 | 1.67081 | 0.93100 | 0.52278 | 0.16365 | 1.61743 | 0.66308 | 0.41138 | 0.11357 | 1.18803 | 4.476 | 49.74 |
| 32 | AEFA | artificial electric field algorithm | 0.87700 | 0.61753 | 0.25235 | 1.74688 | 0.92729 | 0.72698 | 0.18064 | 1.83490 | 0.66615 | 0.11631 | 0.09508 | 0.87754 | 4.459 | 49.55 |
| 33 | AEO | artificial ecosystem-based optimization algorithm | 0.91380 | 0.46713 | 0.26470 | 1.64563 | 0.90223 | 0.43705 | 0.21400 | 1.55327 | 0.66154 | 0.30800 | 0.28563 | 1.25517 | 4.454 | 49.49 |
| 34 | ACOm | ant colony optimization M | 0.88190 | 0.66127 | 0.30377 | 1.84693 | 0.85873 | 0.58680 | 0.15051 | 1.59604 | 0.59667 | 0.37333 | 0.02472 | 0.99472 | 4.438 | 49.31 |
| 35 | BFO-GA | bacterial foraging optimization - ga | 0.89150 | 0.55111 | 0.31529 | 1.75790 | 0.96982 | 0.39612 | 0.06305 | 1.42899 | 0.72667 | 0.27500 | 0.03525 | 1.03692 | 4.224 | 46.93 |
| 36 | SOA | simple optimization algorithm | 0.91520 | 0.46976 | 0.27089 | 1.65585 | 0.89675 | 0.37401 | 0.16984 | 1.44060 | 0.69538 | 0.28031 | 0.10852 | 1.08422 | 4.181 | 46.45 |
| 37 | ABH | artificial bee hive algorithm | 0.84131 | 0.54227 | 0.26304 | 1.64663 | 0.87858 | 0.47779 | 0.17181 | 1.52818 | 0.50923 | 0.33877 | 0.10397 | 0.95197 | 4.127 | 45.85 |
| 38 | ACMO | atmospheric cloud model optimization | 0.90321 | 0.48546 | 0.30403 | 1.69270 | 0.80268 | 0.37857 | 0.19178 | 1.37303 | 0.62308 | 0.24400 | 0.10795 | 0.97503 | 4.041 | 44.90 |
| 39 | ADAMm | adaptive moment estimation M | 0.88635 | 0.44766 | 0.26613 | 1.60014 | 0.84497 | 0.38493 | 0.16889 | 1.39880 | 0.66154 | 0.27046 | 0.10594 | 1.03794 | 4.037 | 44.85 |
| 40 | CGO | chaos game optimization | 0.57256 | 0.37158 | 0.32018 | 1.26432 | 0.61176 | 0.61931 | 0.62161 | 1.85267 | 0.37538 | 0.21923 | 0.19028 | 0.78490 | 3.902 | 43.35 |
| 41 | ATAm | artificial tribe algorithm M | 0.71771 | 0.55304 | 0.25235 | 1.52310 | 0.82491 | 0.55904 | 0.20473 | 1.58867 | 0.44000 | 0.18615 | 0.09411 | 0.72026 | 3.832 | 42.58 |
| 42 | ASHA | artificial showering algorithm | 0.89686 | 0.40433 | 0.25617 | 1.55737 | 0.80360 | 0.35526 | 0.19160 | 1.35046 | 0.47692 | 0.18123 | 0.09774 | 0.75589 | 3.664 | 40.71 |
| 43 | ASBO | adaptive social behavior optimization | 0.76331 | 0.49253 | 0.32619 | 1.58202 | 0.79546 | 0.40035 | 0.26097 | 1.45677 | 0.26462 | 0.17169 | 0.18200 | 0.61831 | 3.657 | 40.63 |
| 44 | MEC | mind evolutionary computation | 0.69533 | 0.53376 | 0.32661 | 1.55569 | 0.72464 | 0.33036 | 0.07198 | 1.12698 | 0.52500 | 0.22000 | 0.04198 | 0.78698 | 3.470 | 38.55 |
| 45 | CSA | circle search algorithm | 0.66560 | 0.45317 | 0.29126 | 1.41003 | 0.68797 | 0.41397 | 0.20525 | 1.30719 | 0.37538 | 0.23631 | 0.10646 | 0.71815 | 3.435 | 38.17 |
| R.W. | 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 | |
Conclusiones
Tras haber desarrollado y probado el algoritmo del restaurador de éxito (SRA), podemos afirmar sin temor a equivocarnos que ha demostrado su valía. El algoritmo ocupa actualmente el puesto 20 en la tabla de clasificación, lo que está bastante bien para ser un concepto nuevo. Tras analizar los resultados, hemos observado algunas peculiaridades en su comportamiento. En problemas de pequeña dimensionalidad, se observa una dispersión de los resultados. Esto resulta especialmente notable en la función discreta "Megacity", donde el algoritmo tiene una dispersión de valores particularmente grande. Esta función es muy compleja para los algoritmos y atascarse en extremos locales supone más una regla que la excepción.
En tareas de gran dimensionalidad, el SRA muestra resultados un poco más débiles de lo que nos gustaría. Esto se debe probablemente a que, en espacios multidimensionales, la estrategia de mejora, en el peor de los casos, requiere un ajuste más fino de los parámetros de temperatura y velocidad de enfriamiento.
No obstante, considero que el SRA es un algoritmo decente con potencial de mejora. Su metáfora culinaria no solo hace comprensible el algoritmo, sino que también abre el camino a modificaciones intuitivas, retocando el mecanismo de mutación adaptativa y pudiendo experimentar con distintos esquemas de selección de "comidas de donantes".
Al crear el algoritmo del restaurador de éxito, mi objetivo no era tanto lograr la superioridad sobre los métodos de optimización existentes, sino descubrir nuevos horizontes conceptuales a través de una original metáfora vital. Los resultados del estudio demuestran claramente que este enfoque merece su lugar en el ecosistema de los algoritmos metaheurísticos.
A mi juicio, ha resultado inesperadamente productiva la idea de centrarse en la peor solución de una población, utilizándola como base para la experimentación: un concepto que a primera vista puede parecer delirante. Sin embargo, es precisamente este principio de "rehabilitar a las ovejas negras" el que libera un sorprendente potencial de optimización. Al igual que un hábil restaurador transforma un plato impopular en un futuro éxito, el algoritmo transforma las soluciones débiles en otras mejores usando como material los ingredientes de los líderes.
Esta experiencia confirma una valiosa regla de la investigación científica: incluso las ideas menos ortodoxas, al aplicarse correctamente, pueden reportar beneficios prácticos. Los enfoques no convencionales suelen revelar facetas de un problema que pasan desapercibidas a las metodologías tradicionales.
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 e inconvenientes del algoritmo SRA:
Ventajas:
- Implementación sencilla.
- Los resultados son buenos.
Desventajas:
- No tiene inconvenientes importantes.
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 población optimizaciones |
| 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_SRA.mq5 | Script | Banco de pruebas para SRA |
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/17380
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.
Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 13): Herramienta RSI Sentinel
Redes neuronales en el trading: Integración de la teoría del caos en la previsión de series temporales (Final)
Gestor de riesgos profesional remoto para Forex en Python
Creación de un Panel de administración de operaciones en MQL5 (Parte IX): Organización del código (II): Modularización
- 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