scikit opt
0.6.5
Intelligence en essaim en Python
(Algorithme génétique, optimisation des essaims de particules, recuit simulé, algorithme de colonie de fourmis, algorithme immunitaire, algorithme d'essaim de poissons artificiels en Python)
Documentation : https://scikit-opt.github.io/scikit-opt/#/en/
Lire la suite : https://scikit-opt.github.io/scikit-opt/#/zh/
Code source : https://github.com/guofei9987/scikit-opt
Aidez-nous à améliorer scikit-opt https://www.wjx.cn/jq/50964691.aspx
pip installer scikit-opt
Pour la version développeur actuelle :
git clone [email protected]:guofei9987/scikit-opt.git
cd scikit-opt
pip install .UDF (fonction définie par l'utilisateur) est disponible dès maintenant !
Par exemple, vous venez de développer un nouveau type de fonction selection .
Maintenant, votre fonction selection ressemble à ceci :
-> Code de démonstration : examples/demo_ga_udf.py#s1
# étape 1 : définissez votre propre opérateur :def selection_tournament(algorithm, tourn_size):FitV = algorithm.FitVsel_index = []for i in range(algorithm.size_pop):aspirants_index = np.random.choice(range(algorithm.size_pop), size =tourn_size)sel_index.append(max(aspirants_index, key=lambda i : FitV[i]))algorithm.Chrom = algorithm.Chrom[sel_index, :] # algorithme de retour de nouvelle génération.Chrom
Importer et créer ga
-> Code de démonstration : examples/demo_ga_udf.py#s2
importer numpy en tant que npfrom sko.GA importer 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], précision=[1e-7, 1e-7, 1])
Enregistrez votre UDF auprès de GA
-> Code de démonstration : examples/demo_ga_udf.py#s3
ga.register(operator_name='selection', Operator=selection_tournament, tourn_size=3)
scikit-opt fournit également certains opérateurs
-> Code de démonstration : examples/demo_ga_udf.py#s4
à partir de sko.operators import classement, sélection, croisement, mutationga.register (operator_name='ranking', Operator=ranking.ranking). registre(operator_name='crossover', Operator=crossover.crossover_2point). registre(operator_name='mutation', Operator=mutation.mutation)
Maintenant, faites GA comme d'habitude
-> Code de démonstration : examples/demo_ga_udf.py#s5
best_x, best_y = ga.run()print('best_x:', best_x, 'n', 'best_y:', best_y)Jusqu'à présent, le
crossoverudf surport,mutation,selectionetrankingde GA scikit-opt fournissent une douzaine d'opérateurs, voir ici
Pour les utilisateurs avancés :
-> Code de démonstration : examples/demo_ga_udf.py#s6
class MyGA(GA):def selection(self, tourn_size=3):FitV = self.FitVsel_index = []for i in range(self.size_pop):aspirants_index = np.random.choice(range(self.size_pop), size =tourn_size)sel_index.append(max(aspirants_index, key=lambda i: FitV[i]))self.Chrom = self.Chrom[sel_index, :] # next Generationreturn 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], précision=[1e-7, 1e-7, 1])best_x, best_y = my_ga.run()print('best_x :', best_x, 'n', 'best_y:', best_y) (Nouveau dans la version 0.3.6)
Exécutez un algorithme pendant 10 itérations, puis exécutez 20 autres itérations en vous basant sur les 10 itérations précédentes :
depuis sko.GA import GAfunc = lambda x: x[0] ** 2ga = GA(func=func, n_dim=1)ga.run(10)ga.run(20)
vectorisation
multithreading
multitraitement
mis en cache
voir https://github.com/guofei9987/scikit-opt/blob/master/examples/example_function_modes.py
Nous développons le calcul GPU, qui sera stable sur la version 1.0.0
Un exemple est déjà disponible : https://github.com/guofei9987/scikit-opt/blob/master/examples/demo_ga_gpu.py
Étape 1 : définissez votre problème
-> Code démo : examples/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 = pré-retour x1 ** 2 + x2 ** 2 + x3 ** 2constraint_eq = [lambda x : 1 - x[1] - x[2] ]constraint_ueq = [lambda x : 1 - x[0] * x[1],lambda x : x[0] * x[1] - 5]
Étape 2 : faire une évolution différentielle
-> Code de démonstration : examples/demo_de.py#s2
depuis sko.DE import 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 =constraint_ueq)best_x, best_y = de.run()print('best_x:', best_x, 'n', 'best_y:', best_y) Étape 1 : définissez votre problème
-> Code de démonstration : examples/demo_ga.py#s1
import numpy as npdef schaffer(p):''' Cette fonction a beaucoup de minimum local, avec de forts chocs minimum global à (0,0) avec la valeur 0 https://en.wikipedia.org/wiki/Test_functions_for_optimization ''' x1, x2 = ppart1 = np.square(x1) - np.square(x2)part2 = np.square(x1) + np.square(x2)retour 0,5 + (np.square(np.sin(part1)) - 0,5) / np.square(1 + 0,001 * partie2)
Étape 2 : faire un algorithme génétique
-> Code démo : examples/demo_ga.py#s2
depuis sko.GA import GAga = GA(func=schaffer, n_dim=2, size_pop=50, max_iter=800, prob_mut=0.001, lb=[-1, -1], ub=[1, 1], précision=1e -7)best_x, best_y = ga.run()print('best_x:', best_x, 'n', 'meilleur_y :', meilleur_y)-> Code démo : examples/demo_ga.py#s3
importer des pandas en tant que pdimport matplotlib.pyplot en tant que pltY_history = pd.DataFrame(ga.all_history_Y)fig, ax = plt.subplots(2, 1)ax[0].plot(Y_history.index, Y_history.values, '.', color='red')Y_history.min(axis=1).cummin().plot(kind='line')plt.show()
Importez simplement le GA_TSP , cela surcharge le crossover , mutation pour résoudre le TSP
Étape 1 : définissez votre problème. Préparez vos coordonnées de points et la matrice de distance.
Ici, je génère les données de manière aléatoire sous forme de démo :
-> Code de démonstration : examples/demo_ga_tsp.py#s1
importer numpy en tant que npfrom scipy importer spatialimport matplotlib.pyplot en tant que pltnum_points = 50points_coordonnée = np.random.rand(num_points, 2) # générer les coordonnées des pointsdistance_matrix = spatial.distance.cdist(points_coordonnée, points_coordonnée, métrique='euclidean')def cal_total_distance( routine):'''La fonction objectif. routine d'entrée, renvoie la distance totale. cal_total_distance(np.arange(num_points)) '''num_points, = routine.shapereturn sum([distance_matrix[routine[i % num_points], routine[(i + 1) % num_points]] pour i in range(num_points)])
Étape 2 : faire GA
-> Code démo : examples/demo_ga_tsp.py#s2
depuis sko.GA import 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()
Étape 3 : Tracez le résultat :
-> Code démo : examples/demo_ga_tsp.py#s3
fig, ax = plt.subplots(1, 2)best_points_ = np.concatenate([best_points, [best_points[0]]])best_points_coordonnée = points_coordonnée[meilleurs_points_, :]ax[0].plot(meilleure_points_coordonnée[:, 0] , meilleures_coordonnées_points[:, 1], 'ou')ax[1].plot(ga_tsp. Generation_best_Y)plt.show()
Étape 1 : définissez votre problème :
-> Code démo : examples/demo_pso.py#s1
def demo_func(x):x1, x2, x3 = xreturn x1 ** 2 + (x2 - 0,05) ** 2 + x3 ** 2
Étape 2 : faire du PSO
-> Code de démonstration : examples/demo_pso.py#s2
depuis sko.PSO import 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('best_x est ', pso.gbest_x, 'best_y est', pso.gbest_y) Étape 3 : Tracez le résultat
-> Code de démonstration : examples/demo_pso.py#s3
importer matplotlib.pyplot en tant que pltplt.plot(pso.gbest_y_hist)plt.show()
Si vous n'avez besoin d'aucune contrainte linéaire comme (x[0] - 1) ** 2 + (x[1] - 0) ** 2 - 0.5 ** 2<=0
Les codes sont comme ceci :
constraint_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]
, contrainte_ueq=constraint_ueq) Notez que vous pouvez ajouter plusieurs contraintes non linéaires. Ajoutez-le simplement à constraint_ueq
De plus, nous avons une animation :
↑ voir examples/demo_pso_ani.py
Étape 1 : définissez votre problème
-> Code de démonstration : examples/demo_sa.py#s1
demo_func = lambda x : x[0] ** 2 + (x[1] - 0,05) ** 2 + x[2] ** 2
Étape 2 : faire SA
-> Code démo : examples/demo_sa.py#s2
depuis sko.SA import 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('meilleur_x:', meilleur_x, 'meilleur_y', meilleur_y) Étape 3 : Tracez le résultat
-> Code démo : examples/demo_sa.py#s3
importer matplotlib.pyplot en tant que pltimport pandas en tant que pdplt.plot(pd.DataFrame(sa.best_y_history).cummin(axis=0))plt.show()
De plus, scikit-opt propose 3 types de recuit simulé : Fast, Boltzmann, Cauchy. Voir plus sa
Étape 1 : oh oui, définissez vos problèmes. Trop ennuyeux de copier cette étape.
Étape 2 : DO SA pour TSP
-> Code démo : examples/demo_sa_tsp.py#s2
depuis sko.SA import 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 (meilleurs_points))
Étape 3 : tracer le résultat
-> Code démo : examples/demo_sa_tsp.py#s3
à partir de matplotlib.ticker import FormatStrFormatterfig, ax = plt.subplots(1, 2)best_points_ = np.concatenate([best_points, [best_points[0]]])best_points_coordonnée = points_coordonnée[meilleurs_points_, :]ax[0].plot(sa_tsp.best_y_history)ax[0].set_xlabel("Itération")ax[0].set_ylabel("Distance")ax[1].plot(best_points_coordonnée[:, 0], best_points_coordonnée [:, 1], marqueur='o', marqueurfacecolor='b', couleur='c', linestyle='-')ax[1].xaxis.set_major_formatter(FormatStrFormatter('%.3f'))ax[1].yaxis.set_major_formatter(FormatStrFormatter('%.3f'))ax[1].set_xlabel(" Longitude")ax[1].set_ylabel("Latitude")plt.show()Plus : Tracez l'animation :
↑ voir examples/demo_sa_tsp.py
-> Code de démonstration : examples/demo_aca_tsp.py#s2
depuis sko.ACA import 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()
-> Code démo : examples/demo_ia.py#s2
depuis sko.IA import 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 routine:', meilleurs_points, 'meilleure_distance:', meilleure_distance)-> Code de démonstration : examples/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, pas=0,5, visuel=0,3,q=0,98, delta=0,5)best_x, best_y = afsa.run()print(best_x, best_y)
Yu, J., He, Y., Yan, Q. et Kang, X. (2021). SpecView : cadre de visualisation du spectre des logiciels malveillants avec transformation du spectre singulier. Transactions IEEE sur la criminalistique et la sécurité de l'information, 16, 5093-5107.
Zhen, H., Zhai, H., Ma, W., Zhao, L., Weng, Y., Xu, Y., ... et He, X. (2021). Conception et tests d'un générateur de solution de flux de puissance optimal basé sur l'apprentissage par renforcement. Rapports énergétiques.
Heinrich, K., Zschech, P., Janiesch, C. et Bonin, M. (2021). Les propriétés des données de processus sont importantes : introduction de réseaux neuronaux convolutifs fermés (GCNN) et de réseaux d'attention à prédiction de valeurs clés (KVP) pour la prédiction des prochains événements avec l'apprentissage en profondeur. Systèmes d'aide à la décision, 143, 113494.
Tang, Hong Kong et Goh, Saskatchewan (2021). Un nouvel optimiseur méta-heuristique non basé sur la population inspiré de la philosophie du Yi Jing. Préimpression arXiv arXiv:2104.08564.
Wu, G., Li, L., Li, X., Chen, Y., Chen, Z., Qiao, B., ... et Xia, L. (2021). Intégration de graphiques basés sur la correspondance d'événements sociaux en temps réel pour les recommandations des EBSN. Web mondial, 1-22.
Pan, X., Zhang, Z., Zhang, H., Wen, Z., Ye, W., Yang, Y., ... et Zhao, X. (2021). Un algorithme rapide et robuste d'identification et de détection de concentration de mélanges de gaz basé sur un mécanisme d'attention équipé d'un réseau neuronal récurrent avec fonction de double perte. Capteurs et actionneurs B : Chimique, 342, 129982.
Castella Balcell, M. (2021). Optimisation du système de maintien en station de l'éolienne flottante offshore WindCrete.
Zhai, B., Wang, Y., Wang, W. et Wu, B. (2021). Stratégie optimale de contrôle de la limite de vitesse variable sur les segments d'autoroute dans des conditions de brouillard. Préimpression arXiv arXiv :2107.14406.
Ouais, XH (2021). Classification multi-étiquettes sur données localement linéaires : Application à la prévision de la toxicité chimique.
Gebhard, L. (2021). Planification de l'expansion des réseaux basse tension à l'aide de l'optimisation des colonies de fourmis Ausbauplanung von Niederspannungsnetzen mithilfe eines Ameisenalgorithmus.
Ma, X., Zhou, H. et Li, Z. (2021). Conception optimale pour les interdépendances entre les systèmes à hydrogène et électriques. Transactions IEEE sur les applications industrielles.
de Curso, TDC (2021). Estudo do modelo Johansen-Ledoit-Sornette de bolhas financeiras.
Wu, T., Liu, J., Liu, J., Huang, Z., Wu, H., Zhang, C., ... et Zhang, G. (2021). Un nouveau cadre basé sur l'IA pour la planification de trajectoire optimale AoI dans les réseaux de capteurs sans fil assistés par UAV. Transactions IEEE sur les communications sans fil.
Liu, H., Wen, Z. et Cai, W. (août 2021). FastPSO : vers un algorithme efficace d'intelligence par essaim sur les GPU. Dans la 50e Conférence internationale sur le traitement parallèle (pp. 1-10).
Mahbub, R. (2020). Algorithmes et techniques d'optimisation pour résoudre le TSP.
Li, J., Chen, T., Lim, K., Chen, L., Khan, SA, Xie, J. et Wang, X. (2019). Synthèse accélérée de nanoclusters d’or par apprentissage profond. Systèmes intelligents avancés, 1(3), 1900029.
