Algoritmos de optimización de la población: Algoritmo electromagnético (ElectroMagnetism-like algorithm, ЕМ)

Contenido:

1. Introducción
2. Descripción del algoritmo
3. Resultados de las pruebas

1. Introducción

En las últimas décadas, investigadores de todo el mundo han ideado muchos métodos de búsqueda metaheurística para resolver problemas complejos de optimización global, así como formas de mejorarlos.

El algoritmo del mecanismo de tipo electromagnético (EM) es un algoritmo de búsqueda metaheurística relativamente nuevo, y se basa en la simulación del comportamiento de las partículas electromagnéticas en el espacio físico, introducido por primera vez por I. Birbil y S.C. Fang en 2003. Se describe como un algoritmo evolutivo con ruido aleatorio y una población basada en la fuerza electromagnética de la interacción entre partículas cargadas.

Este algoritmo está inspirado en el mecanismo de atracción y repulsión de cargas en la teoría del electromagnetismo, y se usa para resolver problemas de optimización no lineal sin restricciones en un dominio continuo. Debido a su capacidad para resolver problemas complejos de optimización global, el EM se usa ampliamente como herramienta de optimización en muchas áreas.

Datos interesantes sobre el electromagnetismo y las cargas eléctricas:

• Existen dos tipos de cargas eléctricas: positivas y negativas. Todas las cargas son positivas o negativas.
• El campo electromagnético se puede usar para transmitir información en forma de ondas de radio. Lo usamos todos los días al escuchar la radio o ver la televisión.
• También tenemos el campo magnético de la Tierra, que nos protege del viento solar y los rayos cósmicos.
• Hay varios materiales que se pueden magnetizar, y esto hace posible la creación de electroimanes. Los electroimanes se usan en diversas aplicaciones, como generadores de energía.
• Existen muchas aplicaciones basadas en el electromagnetismo. Por ejemplo, las computadoras, los teléfonos móviles y otros dispositivos utilizan tecnología electromagnética en su funcionamiento.
• Todos los objetos luminosos (por ejemplo, las bombillas, las luces de los automóviles) emiten radiación electromagnética.
• El electromagnetismo también juega un papel muy importante en la medicina. Los aparatos médicos utilizados para realizar resonancias magnéticas y tomografías computarizadas usan un campo electromagnético para crear imágenes dentro del cuerpo.
• Algunos animales, como los tiburones y las anguilas eléctricas, pueden utilizar el electromagnetismo para navegar en el espacio.
• El electromagnetismo es una de las cuatro fuerzas fundamentales de la naturaleza, junto con la fuerza gravitacional, las fuerza nuclear débil y la fuerza nuclear fuerte.

2. Descripción del algoritmo

Guiado por la teoría del electromagnetismo, el EM simula el mecanismo de atracción-repulsión de cargas para lograr una solución óptima global usando variables limitadas. En el algoritmo, todas las soluciones se consideran partículas cargadas en el espacio de búsqueda, y la carga de cada partícula se relaciona con el valor de la función objetivo. Las partículas con mejor salida objetiva aplicarán fuerzas de atracción, mientras que las partículas con peores valores objetivos aplicarán fuerzas repulsivas a otras partículas. Cuanto mejor sea el valor de la función objetivo, mayor será la magnitud de atracción o repulsión entre las partículas.

El principio del algoritmo es que en la etapa inicial se forma una población de soluciones aleatorias y cada solución se representa con un vector de coordenadas correspondientes a las cargas de las partículas electromagnéticas. Además, con cada iteración del algoritmo, el movimiento de estas cargas en el espacio se simula bajo la acción de fuerzas electromagnéticas. Durante el movimiento, cada carga interactúa con otras cargas, provocando un cambio en la dirección del movimiento y la velocidad. Como resultado, se da una convergencia gradual de soluciones al valor óptimo de la función objetivo.

Los componentes principales del algoritmo de EM son:

1. La formación de la población inicial de soluciones (cargas), donde cada carga está representada por un vector de coordenadas y se corresponde con una determinada solución del problema de optimización.
2. El cálculo de la fuerza electromagnética de interacción entre cargas. Este se realiza en cada iteración del algoritmo y depende de la distancia entre las cargas (soluciones).
3. El movimiento de cargas en el espacio bajo la influencia de fuerzas electromagnéticas de interacción.
4. La actualización de la población de la solución en cada iteración usando la función objetivo (la función objetivo puede ser, por ejemplo, la función de pérdida en problemas de aprendizaje automático).
5. La determinación de la condición para detener el algoritmo, por ejemplo, alcanzar un cierto valor de la función objetivo.

Las partículas interactúan unas con otras, atrayéndose o repeliéndose según la carga y la distancia entre ellas. El algoritmo se ejecuta en varias iteraciones; en cada una de ellas se actualizan las coordenadas y las cargas de las partículas, así como el cálculo de los nuevos valores de la función de aptitud.

La unidad lógica del algoritmo de optimización EM es una partícula. Podemos describirla usando la estructura S_Particle, que es un agente en el espacio de búsqueda. Cada partícula tiene coordenadas c[], que determinan su posición en el espacio de búsqueda, así como una carga C, que influye en la interacción con otras partículas. Para cada partícula se calcula el valor de la función de aptitud f, que evalúa la calidad de la solución correspondiente a la coordenada dada. Además, para cada partícula, se calculan las distancias R hasta otras partículas y los vectores de fuerza F, que determinan la dirección del movimiento de las partículas en el espacio de búsqueda.

//——————————————————————————————————————————————————————————————————————————————
struct S_Particle
{
  double c  [];   //coordinates
  double C;       //charge
  double f;       //fitness
  double R  [];   //euclidean distance to other particles
  double F  [];   //force vector
};
//——————————————————————————————————————————————————————————————————————————————

La clase C_AO_EM es una implementación del algoritmo de optimización electromagnética, y se utiliza para encontrar los valores óptimos de una función dada sobre algún conjunto de números reales. El algoritmo se basa en la simulación de los procesos de interacción entre partículas magnéticas y eléctricas en un sistema físico.

La clase contiene los campos que siguen:

• S_Particle p[] — array de partículas que representan las posibles soluciones al problema de optimización.
• double rangeMax[] — array de valores máximos del rango de búsqueda para cada coordenada.
• double rangeMin[] — array de valores mínimos del rango de búsqueda para cada coordenada.
• double rangeStep[] — array de pasos de búsqueda para cada coordenada.
• double cB[] — array de coordenadas de la mejor solución.
• double fB — valor de la función de la mejor solución.

La clase contiene los métodos siguientes:

• void Init() — inicializa el algoritmo, configurando el número de coordenadas, el número de partículas, la constante del entorno y el paso de movimiento.
• void Moving(int iter) — ejecuta la iteración del algoritmo, moviendo las partículas según las reglas para la interacción de campos magnéticos y eléctricos.
• void Revision() — realiza una revisión de las partículas, verificando si van más allá del rango de búsqueda y ajustando su posición si fuera necesario.

La clase también contiene los siguientes campos privados:

• int coordinatesNumber — número de coordenadas.
• int particlesNumber — número de partículas.
• double envConstant — constante de entorno.
• double movConstant — paso de movimiento.
• double exponent — exponente de distancia.
• double vect[] — array de vectores.
• bool revision — bandera que indica la necesidad de una revisión de partículas.

La clase contiene los siguientes métodos privados:

• double SeInDiSp(double In, double InMin, double InMax, double Step) — distribuye los puntos en una cuadrícula uniforme.
• double RNDfromCI(double min, double max) — genera un número aleatorio en el rango dado.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_EM
{
  //----------------------------------------------------------------------------
  public: S_Particle p     []; //particles
  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //minimum search range
  public: double rangeStep []; //step search
  public: double cB        []; //best coordinates
  public: double fB;           //FF of the best coordinates

  public: void Init (const int    coordinatesNumberP, //coordinates number
                     const int    particlesNumberP,   //particles number
                     const double envConstantP,       //environmental constant
                     const double movConstantP,       //movement step
                     const double exponentP);         //exponent

  public: void Moving   ();
  public: void Revision ();

  //----------------------------------------------------------------------------
  private: int    coordinatesNumber; //coordinates number
  private: int    particlesNumber;   //particles number
  private: double envConstant;       //environmental constant
  private: double movConstant;       //movement step
  private: double exponent;          //exponent
  private: double vect    [];        //vector
  private: bool   revision;

  private: double SeInDiSp  (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI (double min, double max);
};
//——————————————————————————————————————————————————————————————————————————————

El método de inicialización del algoritmo de optimización "algoritmo electromagnético" comienza con el reinicio del generador de números aleatorios y el establecimiento de los valores iniciales para algunas variables. Luego, el método toma como entrada varios parámetros: el número de coordenadas, el número de partículas, el valor del entorno y el paso de movimiento. A continuación, el método crea varios arrays con los tamaños requeridos y los rellena con valores iniciales.

Los arrays almacenan los valores máximos y mínimos del rango para cada coordenada y el paso de cambio de la coordenada, así como el vector y la posición actual de cada partícula. Luego, el método crea un array de partículas y, para cada partícula, crea los arrays necesarios para almacenar sus coordenadas, el array de distancias a otras partículas, el vector de fuerza y ​​el mejor valor actual de la función. Al final, el método crea un array para almacenar la mejor coordenada de todas las partículas. De esta forma, el método inicializa todos los arrays y variables para que funcione el algoritmo de optimización del "algoritmo electromagnético".

//——————————————————————————————————————————————————————————————————————————————
void C_AO_EM::Init (const int    coordinatesNumberP, //coordinates number
                    const int    particlesNumberP,   //particles number
                    const double envConstantP,       //environmental constant
                    const double movConstantP,       //movement step
                    const double exponentP)          //exponent
{
  MathSrand ((int)GetMicrosecondCount ()); // reset of the generator
  fB       = -DBL_MAX;
  revision = false;

  coordinatesNumber = coordinatesNumberP;
  particlesNumber   = particlesNumberP;
  envConstant       = envConstantP;
  movConstant       = movConstantP;
  exponent          = exponentP;

  ArrayResize (rangeMax,  coordinatesNumber);
  ArrayResize (rangeMin,  coordinatesNumber);
  ArrayResize (rangeStep, coordinatesNumber);
  ArrayResize (vect,      coordinatesNumber);

  ArrayResize (p,  particlesNumber);

  for (int i = 0; i < particlesNumber; i++)
  {
    ArrayResize (p [i].c,  coordinatesNumber);
    ArrayResize (p [i].R,  particlesNumber);
    ArrayResize (p [i].F,  coordinatesNumber);
    p [i].f  = -DBL_MAX;
  }

  ArrayResize (cB, coordinatesNumber);
}
//——————————————————————————————————————————————————————————————————————————————

El método Moving() es el primero que se debe ejecutar en cada iteración: es el responsable del movimiento de partículas en el espacio de búsqueda de soluciones. Primero, el método comprueba si las partículas se han inicializado ya. De lo contrario, cada partícula obtiene coordenadas aleatorias dentro de los límites dados y restablece a cero su estimación actual y su carga. También se calcula el vector de diferencias vect[] entre los valores máximos y mínimos en cada dimensión del espacio de búsqueda.

//----------------------------------------------------------------------------
if (!revision)
{
  fB = -DBL_MAX;

  for (int obj = 0; obj < particlesNumber; obj++)
  {
    for (int c = 0; c < coordinatesNumber; c++)
    {
      p [obj].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
      p [obj].c [c] = SeInDiSp (p [obj].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      p [obj].C     = 0.0;
      p [obj].f     = -DBL_MAX;
    }
  }

  for (int c = 0; c < coordinatesNumber; c++)
  {
    vect [c] = rangeMax [c] - rangeMin [c];
  }

  revision = true;
}

Si ya se ha realizado la inicialización, el método calcula la carga de cada partícula según su desviación del máximo global, normalizada hasta la suma de las desviaciones del máximo global de todas las partículas. Calculamos la suma de las diferencias de la forma siguiente:

//calculate the sum of the differences of the fitness of the particles with the global value
for (int obj = 0; obj < particlesNumber; obj++)
{
  sumDiff += fB - p [obj].f;
}

La carga de partículas se calcula usando la fórmula:

p [obj].C = exp (-particlesNumber * ((fB - p [obj].f) / sumDiff));

Como podemos ver, el valor de la carga en la fórmula es un número positivo, el signo de la carga se considerará más adelante en el algoritmo. Si la suma de las diferencias en las desviaciones del máximo global es cero, se supone que la carga de la partícula es cero. La carga calculada de la partícula determinará la amplitud de la fuerza que actúa desde la partícula sobre otras partículas relevantes durante el paso de cálculo de la fuerza. El código para calcular la carga de una partícula tiene el aspecto que sigue:

//calculating the charge of particles=======================================
for (int obj = 0; obj < particlesNumber; obj++)
{
  if (sumDiff == 0.0)
  {
    p [obj].C = 0.0;
  }
  else
  {
    p [obj].C = exp (-particlesNumber * ((fB - p [obj].f) / sumDiff));
  }
}

Antes de comenzar a calcular las distancias entre partículas, debemos restablecer el array de distancias de la partícula hasta las otras partículas, y también restablecer el vector de las fuerzas que actúan sobre la partícula:

//calculation of Euclidean distances between all particles==================
for (int obj = 0; obj < particlesNumber; obj++)
{
  ArrayInitialize (p [obj].R, 0.0);
  ArrayInitialize (p [obj].F, 0.0);
}

Luego calculamos las distancias entre todos los pares de partículas y las fuerzas que actúan entre ellas. Aquí utilizamos una fórmula basada en la ley de Coulomb, que describe la interacción entre partículas cargadas. Las fuerzas que actúan sobre cada partícula se calculan como la suma vectorial de todas las fuerzas que actúan sobre ella partiendo desde otras partículas.

Según la teoría electromagnética, la fuerza de acción de una partícula sobre otra es inversamente proporcional a la distancia entre las dos partículas y directamente proporcional al producto de sus cargas. Una partícula con un valor objetivo más bajo aplica una fuerza repulsiva a una partícula con un valor objetivo relativamente más alto. Asimismo, la partícula alejará a una partícula buena de una región con un mal valor objetivo. Por otra parte, una partícula con un valor objetivo más alto ejerce atracción sobre partículas con valores relativamente más bajos.

Considerando todas las fuerzas relevantes generadas por todas las demás partículas, se calcula el vector de fuerza total para la partícula. Este vector de fuerza combinado determina la dirección en la que se moverá la partícula durante la fase de movimiento de la misma. Los autores del algoritmo recomiendan normalizar el vector de fuerza de la partícula al vector de fuerzas entre todas las partículas: mis experimentos han demostrado que sin normalización los resultados son mejores y el código se presenta sin normalización.

Según qué partícula tenga el mayor valor de la función objetivo, fijamos la dirección de la fuerza (imitación del signo de la carga).

for (int obj = 0; obj < particlesNumber; obj++)
{
  for (int obj2 = 0; obj2 < particlesNumber; obj2++)
  {
    if (obj != obj2)
    {
      if (p [obj].R [obj2] == 0.0)
      {
        for (int c = 0; c < coordinatesNumber; c++)
        {
          diffDist = p [obj].c [c] - p [obj2].c [c];
          p [obj].R [obj2] += diffDist * diffDist;
        }

        p [obj].R [obj2] = sqrt (p [obj].R [obj2]);
        p [obj2].R [obj] = p [obj].R [obj2];

        //calculation of the force------------------------------------------
        Fp = p [obj].C * p [obj2].C / (4.0 * M_PI * envConstant * pow (p [obj].R [obj2], exponent));

        for (int c = 0; c < coordinatesNumber; c++)
        {
          if (p [obj].f > p [obj2].f)
          {
            p [obj ].F [c] += (p [obj2].c [c] - p [obj].c [c]) * Fp;
            p [obj2].F [c] -= (p [obj2].c [c] - p [obj].c [c]) * Fp;

          }
          else
          {
            p [obj ].F [c] -= (p [obj2].c [c] - p [obj].c [c]) * Fp;
            p [obj2].F [c] += (p [obj2].c [c] - p [obj].c [c]) * Fp;
          }
        }
      }
    }
  }
}

Finalmente, se calculan las nuevas coordenadas para cada partícula en función de su posición actual y la fuerza que actúe sobre ella. Cabe señalar que las partículas no poseen masa, lo cual significa que no hay aceleración; las partículas se mueven a una nueva ubicación de forma instantánea, en contraste con el algoritmo de búsqueda gravitacional GSA. Las coordenadas de movimiento se ven limitadas por el rango de búsqueda y el paso de cambio.

El código comentado retorna la partícula en el lado opuesto del rango a una distancia de la coordenada correspondiente en caso de que la partícula esté fuera de rango.

//calculation of particle motions===========================================
for (int obj = 0; obj < particlesNumber; obj++)
{
  for (int c = 0; c < coordinatesNumber; c++)
  {
    r = RNDfromCI (0.0, 1.0);
    p [obj].c [c] = p [obj].c [c] + r * p [obj].F [c] * vect [c] * movConstant;

    //if (p [obj].c [c] > rangeMax [c]) p [obj].c [c] = rangeMin [c] + (p [obj].c [c] - rangeMax [c]);
    //if (p [obj].c [c] < rangeMin [c]) p [obj].c [c] = rangeMax [c] - (rangeMin [c] - p [obj].c [c]);

    p [obj].c [c] = SeInDiSp (p [obj].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
  }
}

El método Revision(), el segundo que debe ejecutarse en cada iteración en el algoritmo de optimización EM, es responsable de comprobar la mejor posición de la partícula en la iteración actual. Dentro del método, itera por todas las partículas y compara el valor de su función de aptitud con el mejor valor actual de fB. Si el valor de la función de aptitud de la partícula actual es mayor que fB, entonces fB se actualiza y la posición de la partícula se copia en el array cB.

Por consiguiente, el método Revision() nos permite monitorear la mejor posición de la partícula en cada iteración del algoritmo y almacenarla en la matriz cB. Esto ayuda a optimizar el proceso de búsqueda de la solución óptima y aumenta la eficiencia del algoritmo.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_EM::Revision ()
{
  for (int s = 0; s < particlesNumber; s++)
  {
    if (p [s].f > fB)
    {
      fB = p [s].f;
      ArrayCopy (cB, p [s].c, 0, 0, WHOLE_ARRAY);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

El método SeInDiSp() en el algoritmo de optimización del "algoritmo electromagnético" se utiliza para limitar los valores de la variable In dentro de un rango dado [InMin, InMax] con un paso Step. Si In es menor o igual que InMin, el método retorna InMin. Si In es mayor o igual que InMax, el método retorna InMax. Si el paso es cero, el método retorna el valor original In. De lo contrario, el método calcula un nuevo valor In usando la fórmula: InMin + Step * (In - InMin) / Step, donde MathRound() es el método para redondear un número al entero más cercano.

Por consiguiente, el método SeInDiSp() nos permite controlar el cambio en el valor de la variable In dentro de los límites especificados y con un paso concreto, lo cual ayuda a optimizar la función de manera más eficiente y rápida.

//——————————————————————————————————————————————————————————————————————————————
// Choice in discrete space
double C_AO_EM::SeInDiSp (double In, double InMin, double InMax, double Step)
{
  if (In <= InMin) return (InMin);
  if (In >= InMax) return (InMax);
  if (Step == 0.0) return (In);
  else return (InMin + Step * (double)MathRound ((In - InMin) / Step));
}
//——————————————————————————————————————————————————————————————————————————————

3. Resultados de las pruebas

Aquí tenemos una copia impresa del funcionamiento del algoritmo electromagnético en el banco de pruebas:

2023.03.26 18:27:39.259    C_AO_EM:50;0.1;0.8
2023.03.26 18:27:39.259    =============================
2023.03.26 18:27:43.215    5 Rastrigin's; Func runs 10000 result: 59.939529106561224
2023.03.26 18:27:43.215    Score: 0.74268
2023.03.26 18:27:52.960    25 Rastrigin's; Func runs 10000 result: 59.780143424645416
2023.03.26 18:27:52.960    Score: 0.74071
2023.03.26 18:29:22.856    500 Rastrigin's; Func runs 10000 result: 63.94951378068386
2023.03.26 18:29:22.856    Score: 0.79237
2023.03.26 18:29:22.856    =============================
2023.03.26 18:29:28.901    5 Forest's; Func runs 10000 result: 0.28698617113254693
2023.03.26 18:29:28.901    Score: 0.16233
2023.03.26 18:29:38.103    25 Forest's; Func runs 10000 result: 0.1571444033424823
2023.03.26 18:29:38.103    Score: 0.08889
2023.03.26 18:30:53.341    500 Forest's; Func runs 10000 result: 0.11734383105881332
2023.03.26 18:30:53.341    Score: 0.06638
2023.03.26 18:30:53.341    =============================
2023.03.26 18:30:58.108    5 Megacity's; Func runs 10000 result: 1.3599999999999999
2023.03.26 18:30:58.108    Score: 0.11333
2023.03.26 18:31:08.897    25 Megacity's; Func runs 10000 result: 0.776
2023.03.26 18:31:08.897    Score: 0.06467
2023.03.26 18:32:23.199    500 Megacity's; Func runs 10000 result: 0.34320000000000006
2023.03.26 18:32:23.199    Score: 0.02860
2023.03.26 18:32:23.199    =============================
2023.03.26 18:32:23.199    All score: 2.79996

Prestando atención a la animación del algoritmo EM sobre las funciones de prueba, uno puede imaginar una especie de "electrificación" del campo del espacio de búsqueda. Las partículas forman grupos de altas cargas siguiendo las características de la superficie de la función de prueba. Por desgracia, la calidad de la convergencia es notablemente baja, aunque la belleza de la imagen resulta innegable.

  EM en la función de prueba Rastrigin.

  EM en la función de prueba Forest.

  EM en la función de prueba Megacity.

Vamos a pasar a los resultados de la prueba del algoritmo de optimización electromagnética. El EM ha mostrado un rendimiento por debajo del promedio en la tabla con una puntuación final de 22. En casi todas las pruebas de seis, el algoritmo ha mostrado malos resultados. Una excepción sería la prueba de la función Rastrigin con 1000 parámetros, en la que el EM ha resultado ser el mejor entre algoritmos tan poderosos como el SSG y el BA. Además, ¡los valores absolutos de la función con 1000 parámetros han resultado mejores que en las pruebas con 10 y 50 parámetros!

Que yo recuerde, esto nunca había sucedido antes, por lo que, con un aumento en el número de parámetros optimizados, los resultados de búsqueda mejorarían. Lo más probable es que este fenómeno esté relacionado con las peculiaridades de la propia estrategia de búsqueda de EM. Conviene destacar la sensibilidad de EM ante la presencia de un gradiente y la diferenciabilidad sobre todo el dominio de definición de la función analizada.

AO	Description	Rastrigin			Rastrigin final	Forest			Forest final	Megacity (discrete)			Megacity final	Final result
		10 params (5 F)	50 params (25 F)	1000 params (500 F)		10 params (5 F)	50 params (25 F)	1000 params (500 F)		10 params (5 F)	50 params (25 F)	1000 params (500 F)
SSG	plantones sembrando y creciendo	1,00000	1,00000	0,55665	2,55665	0,72740	0,94522	1,00000	2,67262	0,76364	0,85977	1,00000	2,62340	100,000
HS	harmony search	0,99676	0,95282	0,48178	2,43136	1,00000	0,98931	0,44806	2,43736	1,00000	1,00000	0,41537	2,41537	92,329
ACOm	ant colony optimization M	0,34611	0,17985	0,17044	0,69640	0,86888	1,00000	0,77362	2,64249	1,00000	0,88930	0,05606	1,94536	65,347
IWO	invasive weed optimization	0,95828	0,67083	0,29807	1,92719	0,70773	0,46349	0,31773	1,48896	0,80000	0,42067	0,33289	1,55356	61,104
COAm	cuckoo optimization algorithm M	0,92400	0,46794	0,26004	1,65199	0,58378	0,34034	0,16526	1,08939	0,72727	0,33025	0,17083	1,22835	47,612
FAm	firefly algorithm M	0,59825	0,33980	0,17135	1,10941	0,51073	0,42299	0,49790	1,43161	0,34545	0,28044	0,35258	0,97847	41,537
ABC	artificial bee colony	0,78170	0,32715	0,20822	1,31707	0,53837	0,21455	0,13344	0,88636	0,56364	0,26569	0,13926	0,96858	36,849
GSA	gravitational search algorithm	0,70167	0,45217	0,00000	1,15384	0,31660	0,36416	0,33204	1,01280	0,59395	0,35054	0,00000	0,94448	36,028
BA	bat algorithm	0,40526	0,63761	0,84451	1,88738	0,20841	0,17477	0,25989	0,64308	0,29698	0,09963	0,17371	0,57032	35,888
BFO	bacterial foraging optimization	0,67203	0,30963	0,11813	1,09979	0,39702	0,26623	0,20652	0,86976	0,52122	0,33211	0,18932	1,04264	34,693
EM	electroMagnetism-like algorithm	0,12235	0,46278	1,00000	1,58513	0,00000	0,03498	0,34880	0,38377	0,00000	0,00000	0,10924	0,10924	22,091
MA	monkey algorithm	0,33192	0,33451	0,14644	0,81287	0,10012	0,07891	0,08932	0,26836	0,21818	0,04243	0,10720	0,36781	13,603
FSS	fish school search	0,46812	0,25337	0,11302	0,83451	0,12840	0,05013	0,06516	0,24369	0,16971	0,04796	0,08283	0,30050	12,655
PSO	particle swarm optimisation	0,20449	0,08200	0,07160	0,35809	0,18895	0,10486	0,21738	0,51119	0,23636	0,05903	0,01957	0,31496	10,031
RND	random	0,16826	0,09743	0,08019	0,34589	0,13496	0,04810	0,04715	0,23021	0,16971	0,03875	0,04922	0,25767	5,302
GWO	grey wolf optimizer	0,00000	0,00000	0,02256	0,02256	0,06570	0,00000	0,00000	0,06570	0,32727	0,07378	0,02557	0,42663	1,000

Conclusiones

1. El algoritmo de EM es un método de optimización eficiente capaz de resolver diversos problemas de optimización, especialmente aquellos relacionados con el procesamiento de grandes cantidades de datos y la alta dimensionalidad en funciones suaves.
2. El algoritmo se basa en la simulación del comportamiento de las partículas electromagnéticas en el espacio físico, lo cual permite lograr un resultado altamente preciso al trabajar con funciones multidimensionales complejas.
3. El algoritmo de EM no requiere cálculos de gradiente, lo que lo hace más versátil y fácil de aplicar a varios problemas, pero resulta sensible a la presencia de un gradiente en la función optimizada.
4. El algoritmo se puede modificar y personalizar según un problema de optimización concreto, lo cual lo convierte en una herramienta flexible para optimizar varias funciones.
5. Existen varias modificaciones del algoritmo de EM que pueden mejorarse con respecto a la versión básica y adaptarse a problemas de optimización específicos.
6. El algoritmo de EM se puede usar en varios campos, como el aprendizaje automático, la inteligencia artificial, la optimización del mercado financiero y otros.

La principal ventaja del algoritmo electromagnético es la capacidad de resolver problemas de optimización en espacios multidimensionales y de gran dimensionalidad, manteniendo una alta precisión del resultado.

Por consiguiente, el algoritmo de EM es una herramienta efectiva para optimizar varias funciones y puede usarse en una amplia gama de problemas de optimización, especialmente cuando se requiere procesar una gran cantidad de datos y/o una alta dimensionalidad.

Esta calificación puede ser útil al elegir el algoritmo más adecuado para resolver un problema de optimización en particular. No obstante, no debe olvidar que la eficiencia del algoritmo depende de muchos factores, como el tamaño del problema, el tipo de función, el número de variables, etc. Por consiguiente, la elección del algoritmo debe basarse en el análisis exhaustivo de un problema en particular.

La figura 1 muestra un histograma con los resultados de las pruebas de los algoritmos.

Figura 1. Histograma con los resultados finales de las pruebas de los algoritmos.

Ventajas y desventajas del algoritmo electromagnético (EM):

Ventajas:
1. Es fácil de aplicar.
2. Muestra una impresionante escalabilidad en funciones suaves.
3. Posee un número reducido de parámetros externos.

Desventajas:
1. Tiene una alta complejidad computacional.
2. Muestra malos resultados en las funciones discretas.
3. El algoritmo se atasca en funciones con "plataformas" horizontales planas.

En cada artículo, adjuntamos un archivo con las versiones actualizadas de los códigos de los algoritmos descritos en artículos anteriores. Los artículos se crean usando como base la experiencia acumulada del autor y su opinión personal, las conclusiones y los juicios se basan en los resultados de los experimentos.