[Algoritmo heurístico] Algoritmo de optimización de lobo gris [con código de implementación de Python]

Escrito en el frente:
En primer lugar, gracias hermanos por suscribirse, lo que me da la motivación para crear. Haré todo lo posible durante el proceso de creación para garantizar la calidad del trabajo. Si tiene alguna pregunta, puede enviarme un mensaje privado. Trabajemos juntos para crear brillantez.

Aunque el camino es largo, pronto llegará; aunque sea difícil, se hará. Mientras tenga la ambición de Yugong de mover montañas, la perseverancia para llevar el agua a través de las rocas, mantener los pies en el suelo, trabajar duro y acumular pasos incluso miles de millas, podrá convertir la gran meta en una hermosa realidad.

Solía ​​​​usar el método de búsqueda de cuadrícula para la optimización de parámetros del modelo antes. Más tarde, descubrí que a todos les gusta usar algoritmos heurísticos de alto nivel "elegantes" para la optimización de parámetros. Recientemente, también comencé a ponerme en contacto con los métodos de optimización de parámetros. He visto: algoritmo de colonia de hormigas, algoritmo de lobo gris, algoritmo de buitre, algoritmo de cuco, algoritmo de enjambre de peces, optimización de colonia de hormigas, algoritmo de enjambre de monos. Me sorprendió cuando vi estos algoritmos con nombres de animales.

Estos algoritmos suenan muy realistas y, de hecho, son muy realistas. Realmente es mejor escuchar lo que tienes que decir. La literatura sin sentido está en pleno juego en la sociedad actual. Más cerca de casa, estos algoritmos son algoritmos maravillosos diseñados por académicos inspirados en la observación del comportamiento de los animales. Los algoritmos con nombres de animales son mucho más que los mencionados anteriormente, como el algoritmo de colonia de abejas, el algoritmo de manada de lobos, el algoritmo de murciélago, el algoritmo de luciérnaga, el algoritmo de beluga, etc., y estos pueden denominarse colectivamente algoritmos heurísticos .

Echemos un vistazo a la definición de algoritmo heurístico, que se toma de la Enciclopedia de Baidu: El algoritmo heurístico (algoritmo heurístico) se propone en relación con el algoritmo de optimización. Un algoritmo óptimo para un problema encuentra la solución óptima para cada instancia del problema. Un algoritmo heurístico se puede definir de la siguiente manera: un algoritmo construido con base en la intuición o la experiencia, brinda una solución factible para cada instancia del problema de optimización combinatoria que se resolverá a un costo aceptable (refiriéndose al tiempo y espacio de cómputo), y el grado de desviación entre la solución factible y la solución óptima generalmente no es predecible. En esta etapa, el algoritmo heurístico se basa principalmente en la imitación del algoritmo del cuerpo natural, que incluye principalmente el algoritmo de colonia de hormigas, el método de recocido simulado, la red neuronal, etc.

Hoy, me gustaría presentar un algoritmo heurístico: Grey Wolf Optimizer (GWO), que es un algoritmo inteligente de optimización de grupos derivado del mecanismo de jerarquía social y el comportamiento de caza de los grupos de lobos grises en la naturaleza. Se ha aplicado con éxito a la programación de producción, la optimización de parámetros y otros campos.

1. Jerarquía de lobos grises

Los lobos grises pertenecen al grupo de cánidos que viven en grupos y son los principales depredadores de la cadena alimenticia y se rigen estrictamente por una jerarquía de dominación social. como muestra la imagen:

Los lobos grises generalmente se dividen en cuatro niveles: los
lobos grises en el primer nivel son los lobos líderes, denotados por α , son los principales responsables de varias tomas de decisiones y luego se emiten a toda la población; los lobos grises en el
segundo nivel se denotan por β , llamados lobos subordinados, que se usan para ayudar a los lobos α en la toma de decisiones u otras actividades de la población; los lobos grises en la tercera fase se denotan por δ , incluidos los lobos exploradores, los lobos guardianes, lobos viejos y lobos depredadores; los
lobos grises en el cuarto nivel se denotan con ω y desempeñan el papel de "chivo expiatorio" en la manada de lobos grises. Al mismo tiempo, deben someterse a otras clases de lobos.

2. Modelo matemático

2.1 Jerarquía

De acuerdo con la jerarquía de lobos grises anterior, la jerarquía social de los lobos grises se puede modelar matemáticamente, y se considera que la solución más adecuada es α , luego la segunda y tercera soluciones óptimas se denotan como β y δ respectivamente , y se supone que el resto de las soluciones son ω . En GWO, la depredación está guiada (optimizada) por α , β y δ , y ω obedece a estos tres lobos.

2.2 Presa circundante

Cuando los lobos grises buscan presas, se acercarán gradualmente y rodearán a la presa. El modelo matemático de presa circundante es el siguiente:

La ecuación (1) representa la distancia entre el individuo y la presa, y la ecuación (2) es la fórmula de actualización de la posición del lobo gris. Entre ellos, t es el álgebra de iteración actual, Xp y X son los vectores de posición de la presa y el lobo gris respectivamente, A y C son los vectores de coeficientes, y sus fórmulas de cálculo son las siguientes:

En la fórmula anterior, a es el factor de convergencia, el valor inicial es 2 y disminuye linealmente a 0 a medida que aumenta el número de iteraciones, y el módulo de r1 y r2 es un número aleatorio entre [0, 1].

2.3 Caza

Los lobos grises tienen la capacidad de identificar la ubicación de presas potenciales (soluciones óptimas), pero se desconocen las características espaciales de muchos problemas, por lo que los lobos grises no pueden determinar la ubicación precisa de las presas (soluciones óptimas). Para simular todo el proceso, aquí se supone que α, β y δ tienen una gran capacidad para identificar posibles posiciones de presas, por lo que en cada proceso de iteración, se conservarán los tres mejores lobos grises (α, β y δ) de la población actual y luego se actualizarán las posiciones de otros agentes de búsqueda (incluido ω) de acuerdo con su información de posición .

El modelo matemático del individuo lobo gris rastreando la ubicación de la presa se describe a continuación:

Estas tres fórmulas representan las distancias entre α, β y δ y otros individuos respectivamente, las distribuciones Xα, Xβ y Xδ representan las posiciones actuales de los tres lobos, C1, C2 y C3 son vectores aleatorios, y X representa la posición actual del lobo gris .

X1, X2 y X3 calculan el tamaño del paso y la dirección de ω lobo en la manada de lobos a α , β y δ , y la fórmula (7) define la posición final de ω .

2.4 Atacando a la presa

Los lobos grises completan la caza atacando cuando la presa deja de moverse. Para simular el acercamiento de la presa, la disminución de un valor hará que el valor de A fluctúe en consecuencia, es decir, en el proceso de a converge de 2 a 0, A cambia en el intervalo [-a, a].

Como se muestra en la figura anterior, cuando el valor de A está dentro del intervalo, la siguiente posición del lobo gris puede estar en cualquier lugar entre su posición actual y la posición de la presa. Cuando |A|<1, los lobos atacan a la presa (caen en el óptimo local), y cuando |A|>1, los lobos grises se separan de la presa, con la esperanza de encontrar una presa más adecuada (óptimo global).

2.5 Caza de presas

Los lobos grises buscan presas principalmente en función de la información de ubicación de α, β y δ. Buscan la información de ubicación de la presa dispersa al principio y luego atacan a la presa juntos. Según la divergencia del modelo matemático, el agente de búsqueda puede verse obligado a mantenerse alejado de la presa a través de |A|>1, lo que permite que el algoritmo de optimización del lobo gris encuentre la solución óptima globalmente. Mientras tanto, otro coeficiente de búsqueda en el algoritmo GWO es C. Se puede saber por la fórmula (4) que C es un valor aleatorio entre [0, 2]. Este coeficiente representa el peso aleatorio del impacto de la posición actual del lobo gris sobre la presa. Si C>1, aumenta, de lo contrario disminuye. Esto ayuda a GWO a mostrar un comportamiento de búsqueda aleatorio durante la optimización y evitar que el algoritmo se atasque en el óptimo local.

3. Proceso de algoritmo

En pocas palabras, hay tres lobos grises α , β y δ en la manada de lobos como el lobo principal, α es el rey lobo, β y δ son el segundo y el tercero respectivamente, β debe escuchar al líder α y δ debe escuchar a α y β . Estos tres lobos guían a los otros lobos de la manada de lobos para encontrar presas, y el proceso de la manada de lobos en busca de presas es el proceso de nuestra búsqueda de la solución óptima.

El flujo de algoritmo específico es el siguiente:

4. Ventajas y desventajas del algoritmo

4.1 Ventajas

1. El algoritmo es fácil de operar
2. Menos configuraciones de parámetros
3. Fuerte robustez
4. La velocidad de convergencia es más rápida que algoritmos similares
5. Mayor precisión

4.2 Desventajas

1. Pobre diversidad de población
2. Velocidad de convergencia lenta en la etapa posterior
3. Fácil de caer en el óptimo local

5. Resumen

En la actualidad, muchos investigadores han propuesto algoritmos mejorados correspondientes para las deficiencias del algoritmo de optimización del lobo gris, y también publicaron algunos artículos, como la optimización de la distribución de la población inicial a través de estrategias de aprendizaje inverso para aumentar las capacidades de búsqueda global, y algunos académicos introdujeron operadores de caos y establecieron parámetros de algoritmo para actualizar las variables de control para hacer frente a las deficiencias del algoritmo de optimización del lobo gris, como la velocidad de convergencia lenta en la etapa posterior y las posibles soluciones óptimas locales.

6. Código

Código GWO:

# -*- coding: utf-8 -*-
"""
Created on Mon Jul 17 11:24:36 2023

@author: zqq
"""


import numpy as np
import matplotlib.pyplot as plt

class GWO:
    def __init__(self):
        self.wolf_num = 15
        self.max_iter = 150
        self.dim = 30
        self.lb = -30*np.ones((self.dim,))
        self.ub = 30*np.ones((self.dim,))
        self.alpha_pos = np.zeros((1,self.dim))
        self.beta_pos = np.zeros((1, self.dim))
        self.delta_pos = np.zeros((1, self.dim))
        self.alpha_score = np.inf
        self.beta_score = np.inf
        self.delta_score = np.inf
        self.convergence_curve = np.zeros((self.max_iter,))
        self.position = np.zeros((self.wolf_num,self.dim))

    def run(self):
        count = 0
        self.init_pos()
        while count < self.max_iter:
            for i in range(self.wolf_num):
                flag_ub = self.position[i,:] > self.ub
                flag_lb = self.position[i,:] < self.lb
                self.position[i,:] = self.position[i,:]*(~(flag_lb+flag_ub))+flag_ub*self.ub+flag_lb*self.lb
                fitness = self.func(self.position[i,:])
                if fitness < self.alpha_score:
                    self.alpha_score = fitness
                    self.alpha_pos = self.position[i,:]
                elif fitness < self.beta_score:
                    self.beta_score = fitness
                    self.beta_pos = self.position[i,:]
                elif fitness < self.delta_score:
                    self.delta_score = fitness
                    self.delta_pos = self.position[i,:]
            a = 2 - count*(2/self.max_iter)
            for i in range(self.wolf_num):
                for j in range(self.dim):
                    alpha = self.update_pos(self.alpha_pos[j],self.position[i,j],a)
                    beta = self.update_pos(self.beta_pos[j], self.position[i, j], a)
                    delta = self.update_pos(self.delta_pos[j], self.position[i, j], a)
                    self.position[i, j] = sum(np.array([alpha, beta, delta]) * np.array([1/3,1/3,1/3]))
            count += 1
            self.convergence_curve[count-1] = self.alpha_score
        self.plot_results()

    def init_pos(self):
        for i in range(self.wolf_num):
            for j in range(self.dim):
                self.position[i,j] = np.random.rand()*(self.ub[j]-self.lb[j])+self.lb[j]

    @staticmethod
    def update_pos(v1,v2,a):
        A = 2*np.random.rand()*a-a
        C = 2*np.random.rand()
        temp = np.abs(C*v1-v2)
        return v1 - A*temp

    def plot_results(self):
        plt.style.use('seaborn-darkgrid')
        plt.plot(range(1,self.max_iter+1),self.convergence_curve,'g.--')
        plt.xlabel('iteration')
        plt.ylabel('fitness')
        plt.title('GWO fitness curve')
        plt.show()

    @staticmethod
    def func(x):
        dim, s = 30, 0
        for i in range(len(x)-1):
            s += 100*(x[i+1]-x[i]**2)**2+(x[i]-1)**2
        return s

if __name__ == "__main__":
    gwo = GWO()
    gwo.run()

Referencias

https://mp.weixin.qq.com/s/wfCnGdQNqJuC8tQf_2tI7A