scikit opt
0.6.5
Inteligencia de enjambre en Python
(Algoritmo genético, optimización de enjambre de partículas, recocido simulado, algoritmo de colonia de hormigas, algoritmo inmunológico, algoritmo de enjambre de peces artificiales en Python)
Documentación: https://scikit-opt.github.io/scikit-opt/#/en/
Siguiente: https://scikit-opt.github.io/scikit-opt/#/zh/
Código fuente: https://github.com/guofei9987/scikit-opt
Ayúdanos a mejorar scikit-opt https://www.wjx.cn/jq/50964691.aspx
instalación de pip scikit-opt
Para la versión actual para desarrolladores:
git clone [email protected]:guofei9987/scikit-opt.git
cd scikit-opt
pip install .¡UDF (función definida por el usuario) ya está disponible!
Por ejemplo, acaba de desarrollar un nuevo tipo de función selection .
Ahora, su función selection es así:
-> Código de demostración: ejemplos/demo_ga_udf.py#s1
# paso 1: defina su propio operador:def Selection_tournament(algorithm, tourn_size):FitV = algoritmo.FitVsel_index = []for i in range(algorithm.size_pop):aspirants_index = np.random.choice(range(algorithm.size_pop), size =tamaño_torneo)sel_index.append(max(indice_aspirantes, clave=lambda i: FitV[i]))algoritmo.Chrom = algoritmo.Chrom[sel_index, :] # algoritmo de retorno de próxima generación.Chrom
Importar y construir ga
-> Código de demostración: ejemplos/demo_ga_udf.py#s2
importar numpy como npdesde sko.GA importar GA, GA_TSPdemo_func = lambda x: x[0] ** 2 + (x[1] - 0.05) ** 2 + (x[2] - 0.5) ** 2ga = GA(func =demo_func, n_dim=3, size_pop=100, max_iter=500, prob_mut=0.001,lb=[-1, -10, -5], ub=[2, 10, 2], precisión=[1e-7, 1e-7, 1])
Registre su udf en GA
-> Código de demostración: ejemplos/demo_ga_udf.py#s3
ga.register(nombre_operador='selección', operador=torneo_selección, tamaño_torneo=3)
scikit-opt también proporciona algunos operadores
-> Código de demostración: ejemplos/demo_ga_udf.py#s4
de sko.operators importa clasificación, selección, cruce, mutaciónga.register(operator_name='ranking', operator=ranking.ranking). registrarse(operator_name='crossover', operador=crossover.crossover_2point). registrarse(nombre_operador='mutación', operador=mutación.mutación)
Ahora haz GA como de costumbre.
-> Código de demostración: ejemplos/demo_ga_udf.py#s5
mejor_x, mejor_y = ga.run()print('mejor_x:', mejor_x, 'n', 'mejor_y:', mejor_y)Hasta ahora, el
crossover,mutation,selectionyrankingde udf surport de GA scikit-opt proporcionan una docena de operadores, consulte aquí
Para usuarios avanzados:
-> Código de demostración: ejemplos/demo_ga_udf.py#s6
clase MyGA(GA):def selección(self, tourn_size=3):FitV = self.FitVsel_index = []for i in range(self.size_pop):aspirants_index = np.random.choice(range(self.size_pop), tamaño =tourn_size)sel_index.append(max(aspirants_index, key=lambda i: FitV[i]))self.Chrom = self.Chrom[sel_index, :] # retorno de próxima generación self.Chromranking = ranking.rankingdemo_func = lambda x: x[0] ** 2 + (x[1] - 0.05) ** 2 + (x[2] - 0.5) ** 2my_ga = MyGA(func=demo_func, n_dim=3, size_pop=100, max_iter=500, lb=[-1, -10, -5], ub=[2, 10, 2], precision=[1e-7, 1e-7, 1])best_x, best_y = my_ga.run() print('mejor_x:', mejor_x, 'n', 'mejor_y:', mejor_y) (Nuevo en la versión 0.3.6)
Ejecute un algoritmo durante 10 iteraciones y luego ejecute otras 20 iteraciones basadas en las 10 iteraciones anteriores:
desde sko.GA importar GAfunc = lambda x: x[0] ** 2ga = GA(func=func, n_dim=1)ga.run(10)ga.run(20)
vectorización
subprocesos múltiples
multiprocesamiento
almacenado en caché
consulte https://github.com/guofei9987/scikit-opt/blob/master/examples/example_function_modes.py
Estamos desarrollando cálculo GPU, que será estable en la versión 1.0.0
Ya hay un ejemplo disponible: https://github.com/guofei9987/scikit-opt/blob/master/examples/demo_ga_gpu.py
Paso 1 : define tu problema
-> Código de demostración: ejemplos/demo_de.py#s1
'''min f(x1, x2, x3) = x1^2 + x2^2 + x3^2s.t. x1*x2 >= 1 x1*x2 <= 5 x2 + x3 = 1 0 <= x1, x2, x3 <= 5'''def obj_func(p):x1, x2, x3 = preturn x1 ** 2 + x2 ** 2 + x3 ** 2constraint_eq = [lambda x: 1 - x[1] - x[2] ]restricción_ueq = [lambda x: 1 - x[0] * x[1],lambda x: x[0] * x[1] - 5]
Paso 2 : hacer evolución diferencial
-> Código de demostración: ejemplos/demo_de.py#s2
desde sko.DE importar DEde = DE(func=obj_func, n_dim=3, size_pop=50, max_iter=800, lb=[0, 0, 0], ub=[5, 5, 5],constraint_eq=constraint_eq, constraint_ueq =restricción_ueq)mejor_x, mejor_y = de.run()print('mejor_x:', mejor_x, 'n', 'mejor_y:', mejor_y) Paso 1 : define tu problema
-> Código de demostración: ejemplos/demo_ga.py#s1
import numpy as npdef schaffer(p):''' Esta función tiene muchos mínimos locales, con fuertes impactos mínimos globales en (0,0) con valor 0 https://en.wikipedia.org/wiki/Test_functions_for_optimization ''' x1, x2 = pparte1 = np.cuadrado(x1) - np.cuadrado(x2)parte2 = np.cuadrado(x1) + np.square(x2)retorna 0.5 + (np.square(np.sin(parte1)) - 0.5) / np.square(1 + 0.001 * parte2)
Paso 2 : hacer algoritmo genético
-> Código de demostración: ejemplos/demo_ga.py#s2
desde sko.GA importar GAga = GA(func=schaffer, n_dim=2, size_pop=50, max_iter=800, prob_mut=0.001, lb=[-1, -1], ub=[1, 1], precision=1e -7)mejor_x, mejor_y = ga.run()print('mejor_x:', mejor_x, 'n', 'mejor_y:', mejor_y)-> Código de demostración: ejemplos/demo_ga.py#s3
importar pandas como pdimport matplotlib.pyplot como pltY_history = pd.DataFrame(ga.all_history_Y)fig, ax = plt.subplots(2, 1)ax[0].plot(Y_history.index, Y_history.values, '.', color='rojo')Y_history.min(axis=1).cummin().plot(kind='line')plt.show()
Simplemente importe GA_TSP , sobrecarga el crossover , mutation para resolver el TSP
Paso 1 : define tu problema. Prepare las coordenadas de sus puntos y la matriz de distancias.
Aquí genero los datos aleatoriamente como demostración:
-> Código de demostración: ejemplos/demo_ga_tsp.py#s1
importar numpy como npfrom scipy importar espacialimport matplotlib.pyplot como pltnum_points = 50points_coordinate = np.random.rand(num_points, 2) # generar coordenadas de puntosdistance_matrix = espacial.distance.cdist(points_coordinate, points_coordinate, metric='euclidean')def cal_total_distance(rutina):''''La función objetivo. Rutina de entrada, retorno de distancia total. cal_total_distance(np.arange(num_points)) '''num_points, = rutina.shapereturn sum([distance_matrix[rutina[i % num_points], rutina[(i + 1) % num_points]] para i en el rango(num_points)])
Paso 2 : hacer GA
-> Código de demostración: ejemplos/demo_ga_tsp.py#s2
desde sko.GA importar GA_TSPga_tsp = GA_TSP(func=cal_total_distance, n_dim=num_points, size_pop=50, max_iter=500, prob_mut=1)best_points, best_distance = ga_tsp.run()
Paso 3 : Traza el resultado:
-> Código de demostración: ejemplos/demo_ga_tsp.py#s3
fig, ax = plt.subplots(1, 2)best_points_ = np.concatenate([best_points, [best_points[0]]])best_points_coordinate = points_coordinate[best_points_, :]ax[0].plot(best_points_coordinate[:, 0] , mejor_coordenada_puntos[:, 1], 'o')ax[1].plot(ga_tsp.generación_best_Y)plt.show()
Paso 1 : define tu problema:
-> Código de demostración: ejemplos/demo_pso.py#s1
def demo_func(x):x1, x2, x3 = xreturn x1 ** 2 + (x2 - 0.05) ** 2 + x3 ** 2
Paso 2 : hacer PSO
-> Código de demostración: ejemplos/demo_pso.py#s2
desde sko.PSO importar PSOpso = PSO(func=demo_func, n_dim=3, pop=40, max_iter=150, lb=[0, -1, 0.5], ub=[1, 1, 1], w=0.8, c1=0.5, c2=0.5)pso.run()print('mejor_x es ', pso.gbest_x, 'best_y es', pso.gbest_y) Paso 3 : trazar el resultado
-> Código de demostración: ejemplos/demo_pso.py#s3
importar matplotlib.pyplot como pltplt.plot(pso.gbest_y_hist)plt.show()
Si necesita una restricción no lineal como (x[0] - 1) ** 2 + (x[1] - 0) ** 2 - 0.5 ** 2<=0
Los códigos son así:
restricción_ueq = (lambda x: (x[0] - 1) ** 2 + (x[1] - 0) ** 2 - 0,5 ** 2,
)pso = PSO(func=demo_func, n_dim=2, pop=40, max_iter=max_iter, lb=[-2, -2], ub=[2, 2]
, restricción_ueq=restricción_ueq) Tenga en cuenta que puede agregar más de una restricción no lineal. Simplemente agréguelo a constraint_ueq
Además, tenemos una animación:
↑ ver ejemplos/demo_pso_ani.py
Paso 1 : define tu problema
-> Código de demostración: ejemplos/demo_sa.py#s1
demo_func = lambda x: x[0] ** 2 + (x[1] - 0,05) ** 2 + x[2] ** 2
Paso 2 : hacer SA
-> Código de demostración: ejemplos/demo_sa.py#s2
desde sko.SA importar SAsa = SA(func=demo_func, x0=[1, 1, 1], T_max=1, T_min=1e-9, L=300, max_stay_counter=150)best_x, best_y = sa.run() print('mejor_x:', mejor_x, 'mejor_y', mejor_y) Paso 3 : trazar el resultado
-> Código de demostración: ejemplos/demo_sa.py#s3
importar matplotlib.pyplot como pltimportar pandas como pdplt.plot(pd.DataFrame(sa.best_y_history).cummin(axis=0))plt.show()
Además, scikit-opt proporciona 3 tipos de recocido simulado: rápido, Boltzmann, Cauchy. Ver más sa
Paso 1 : oh, sí, define tus problemas. Demasiado aburrido copiar este paso.
Paso 2 : HACER SA para TSP
-> Código de demostración: ejemplos/demo_sa_tsp.py#s2
desde sko.SA importar SA_TSPsa_tsp = SA_TSP(func=cal_total_distance, x0=range(num_points), T_max=100, T_min=1, L=10 * num_points)best_points, best_distance = sa_tsp.run()print(best_points, best_distance, cal_total_distance (mejores_puntos))
Paso 3 : traza el resultado
-> Código de demostración: ejemplos/demo_sa_tsp.py#s3
desde matplotlib.ticker import FormatStrFormatterfig, ax = plt.subplots(1, 2)best_points_ = np.concatenate([best_points, [best_points[0]]])best_points_coordinate = points_coordinate[best_points_, :]ax[0].plot(sa_tsp.best_y_history)ax[0].set_xlabel("Iteración")ax[0].set_ylabel("Distancia")ax[1].plot(best_points_coordinate[:, 0], best_points_coordinate [:, 1], marcador='o', marcadorfacecolor='b', color='c', linestyle='-')ax[1].xaxis.set_major_formatter(FormatStrFormatter('%.3f'))ax[1].yaxis.set_major_formatter(FormatStrFormatter('%.3f'))ax[1].set_xlabel(" Longitud")ax[1].set_ylabel("Latitud")plt.show()Más: Traza la animación:
↑ ver ejemplos/demo_sa_tsp.py
-> Código de demostración: ejemplos/demo_aca_tsp.py#s2
desde sko.ACA importar ACA_TSPaca = ACA_TSP(func=cal_total_distance, n_dim=num_points, size_pop=50, max_iter=200, Distance_matrix=distance_matrix)best_x, best_y = aca.run()
-> Código de demostración: ejemplos/demo_ia.py#s2
desde sko.IA importar IA_TSPia_tsp = IA_TSP(func=cal_total_distance, n_dim=num_points, size_pop=500, max_iter=800, prob_mut=0.2,T=0.7, alpha=0.95)best_points, best_distance = ia_tsp.run()print('best rutina:', mejores_puntos, 'mejor_distancia:', mejor_distancia)-> Código de demostración: ejemplos/demo_afsa.py#s1
def func(x):x1, x2 = xreturn 1 / x1 ** 2 + x1 ** 2 + 1 / x2 ** 2 + x2 ** 2from sko.AFSA import AFSAafsa = AFSA(func, n_dim=2, size_pop= 50, max_iter=300,max_try_num=100, paso=0,5, visual=0,3,q=0,98, delta=0.5)mejor_x, mejor_y = afsa.run()print(mejor_x, mejor_y)
Yu, J., He, Y., Yan, Q. y Kang, X. (2021). SpecView: marco de visualización del espectro de malware con transformación de espectro singular. Transacciones IEEE sobre seguridad y análisis de la información, 16, 5093-5107.
Zhen, H., Zhai, H., Ma, W., Zhao, L., Weng, Y., Xu, Y., ... y He, X. (2021). Diseño y pruebas de un generador de solución de flujo de energía óptimo basado en aprendizaje por refuerzo. Informes energéticos.
Heinrich, K., Zschech, P., Janiesch, C. y Bonin, M. (2021). Las propiedades de los datos de proceso son importantes: introducción de redes neuronales convolucionales cerradas (GCNN) y redes de atención de predicción de valores clave (KVP) para la predicción del próximo evento con aprendizaje profundo. Sistemas de apoyo a la decisión, 143, 113494.
Tang, HK y Goh, SK (2021). Un novedoso optimizador metaheurístico no basado en la población inspirado en la filosofía de Yi Jing. Preimpresión de arXiv arXiv:2104.08564.
Wu, G., Li, L., Li, X., Chen, Y., Chen, Z., Qiao, B., ... y Xia, L. (2021). Incrustación de gráficos basada en coincidencias de eventos sociales en tiempo real para la recomendación de EBSN. Web mundial, 1-22.
Pan, X., Zhang, Z., Zhang, H., Wen, Z., Ye, W., Yang, Y., ... y Zhao, X. (2021). Un algoritmo rápido y robusto de identificación de mezclas de gases y detección de concentración basado en un mecanismo de atención equipado con una red neuronal recurrente con función de doble pérdida. Sensores y actuadores B: Químicos, 342, 129982.
Castella Balcell, M. (2021). Optimización del sistema de mantenimiento de estaciones para el aerogenerador marino flotante WindCrete.
Zhai, B., Wang, Y., Wang, W. y Wu, B. (2021). Estrategia óptima de control de límite de velocidad variable en segmentos de autopistas en condiciones de niebla. Preimpresión de arXiv arXiv:2107.14406.
Sí, XH (2021). Clasificación de etiquetas múltiples sobre datos localmente lineales: aplicación a la predicción de la toxicidad química.
Gebhard, L. (2021). Planificación de la expansión de redes de bajo voltaje mediante la optimización de colonias de hormigas Ausbauplanung von Niederspannungsnetzen mithilfe eines Ameisenalgorithmus.
Ma, X., Zhou, H. y Li, Z. (2021). Diseño óptimo para las interdependencias entre los sistemas de hidrógeno y energía. Transacciones IEEE sobre aplicaciones industriales.
de Curso, TDC (2021). Estudio del modelo Johansen-Ledoit-Sornette de bolhas financieras.
Wu, T., Liu, J., Liu, J., Huang, Z., Wu, H., Zhang, C., ... y Zhang, G. (2021). Un nuevo marco basado en IA para la planificación de trayectorias óptimas de AoI en redes de sensores inalámbricos asistidas por UAV. Transacciones IEEE sobre comunicaciones inalámbricas.
Liu, H., Wen, Z. y Cai, W. (agosto de 2021). FastPSO: hacia un algoritmo de inteligencia de enjambre eficiente en GPU. En 50ª Conferencia Internacional sobre Procesamiento Paralelo (págs. 1-10).
Mahbub, R. (2020). Algoritmos y técnicas de optimización para la resolución de TSP.
Li, J., Chen, T., Lim, K., Chen, L., Khan, SA, Xie, J. y Wang, X. (2019). El aprendizaje profundo aceleró la síntesis de nanoclusters de oro. Sistemas inteligentes avanzados, 1(3), 1900029.
