scikit opt
0.6.5
Inteligência de enxame em Python
(Algoritmo Genético, Otimização de Enxame de Partículas, Recozimento Simulado, Algoritmo de Colônia de Formigas, Algoritmo Imune, Algoritmo de Enxame de Peixes Artificiais em Python)
Documentação: https://scikit-opt.github.io/scikit-opt/#/en/
文档: https://scikit-opt.github.io/scikit-opt/#/zh/
Código fonte: https://github.com/guofei9987/scikit-opt
Ajude-nos a melhorar o scikit-opt https://www.wjx.cn/jq/50964691.aspx
pip instalar scikit-opt
Para a versão atual do desenvolvedor:
git clone [email protected]:guofei9987/scikit-opt.git
cd scikit-opt
pip install .UDF (função definida pelo usuário) já está disponível!
Por exemplo, você acabou de desenvolver um novo tipo de função selection .
Agora, sua função selection é assim:
-> Código de demonstração: exemplos/demo_ga_udf.py#s1
# passo 1: defina seu próprio 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 =tourn_size)sel_index.append(max(aspirantes_index, key=lambda i: FitV[i]))algoritmo.Chrom = algoritmo.Chrom[sel_index,:] # algoritmo de retorno da próxima geração.Chrom
Importar e criar ga
-> Código de demonstração: exemplos/demo_ga_udf.py#s2
importar numpy como npfrom 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], precisão=[1e-7, 1e-7, 1])
Registre seu udf no GA
-> Código de demonstração: exemplos/demo_ga_udf.py#s3
ga.register(operator_name='seleção', operador=selection_tournament, tourn_size=3)
scikit-opt também fornece alguns operadores
-> Código de demonstração: exemplos/demo_ga_udf.py#s4
de sko.operators importam classificação, seleção, cruzamento,mutationga.register(operator_name='ranking', operator=ranking.ranking). registrar(operator_name='crossover', operador=crossover.crossover_2point). registrar(nome_operador='mutação', operador=mutação.mutação)
Agora faça GA normalmente
-> Código de demonstração: exemplos/demo_ga_udf.py#s5
best_x, best_y = ga.run()print('best_x:', best_x, 'n', 'best_y:', best_y)Até agora, o
crossover,mutation,selectionerankingdo udf surport do GA scikit-opt fornece uma dúzia de operadores, veja aqui
Para usuários avançados:
-> Código de demonstração: exemplos/demo_ga_udf.py#s6
classe MyGA (GA): seleção def (self, tourn_size = 3): FitV = self.FitVsel_index = [] para i no intervalo (self.size_pop):aspirantes_index = np.random.choice (range (self.size_pop), tamanho =tourn_size)sel_index.append(max(aspirantes_index, key=lambda i: FitV[i]))self.Chrom = self.Chrom[sel_index,:] # próxima geraçãoreturn 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], precisão=[1e-7, 1e-7, 1])best_x, best_y = my_ga.run()print('best_x :', melhor_x, 'n', 'melhor_y:', melhor_y) (Novo na versão 0.3.6)
Execute um algoritmo para 10 iterações e, em seguida, execute outras 20 iterações com base nas 10 iterações anteriores:
de sko.GA importar GAfunc = lambda x: x[0] ** 2ga = GA(func=func, n_dim=1)ga.run(10)ga.run(20)
vetorização
multithreading
multiprocessamento
armazenado em cache
consulte https://github.com/guofei9987/scikit-opt/blob/master/examples/example_function_modes.py
Estamos desenvolvendo a computação GPU, que será estável na versão 1.0.0
Um exemplo já está disponível: https://github.com/guofei9987/scikit-opt/blob/master/examples/demo_ga_gpu.py
Etapa 1 : defina seu problema
-> Código de demonstração: exemplos/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é-turno 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]
Etapa 2 : faça a evolução diferencial
-> Código de demonstração: exemplos/demo_de.py#s2
de 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, restrição_ueq =constraint_ueq)best_x, best_y = de.run()print('best_x:', best_x, 'n', 'melhor_y:', melhor_y) Etapa 1 : defina seu problema
-> Código de demonstração: exemplos/demo_ga.py#s1
import numpy as npdef schaffer(p):''' Esta função tem bastante mínimo local, com fortes choques mínimo global em (0,0) com valor 0 https://en.wikipedia.org/wiki/Test_functions_for_optimization ''' x1, x2 = pparte1 = np.quadrado(x1) - np.quadrado(x2)parte2 = np.quadrado(x1) + np.quadrado(x2)retorno 0,5 + (np.quadrado(np.sin(parte1)) - 0,5) / np.quadrado(1 + 0,001 * parte2)
Etapa 2 : fazer algoritmo genético
-> Código de demonstração: exemplos/demo_ga.py#s2
de 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], precisão=1e -7)melhor_x, melhor_y = ga.run()print('melhor_x:', melhor_x, 'n', 'melhor_y:', melhor_y)-> Código de demonstração: exemplos/demo_ga.py#s3
importar pandas como pdimport matplotlib.pyplot as pltY_history = pd.DataFrame(ga.all_history_Y)fig, ax = plt.subplots(2, 1)ax[0].plot(Y_history.index, Y_history.values, '.', color='vermelho')Y_history.min(axis=1).cummin().plot(kind='line')plt.show()
Basta importar o GA_TSP , ele sobrecarrega o crossover , mutation para resolver o TSP
Passo 1 : defina seu problema. Prepare suas coordenadas de pontos e a matriz de distância.
Aqui eu gero os dados aleatoriamente como uma demonstração:
-> Código de demonstração: exemplos/demo_ga_tsp.py#s1
importar numpy as npfrom scipy importar espacialimport matplotlib.pyplot as pltnum_points = 50points_coordenada = np.random.rand(num_points, 2) # gerar coordenada de pontosdistance_matrix = espacial.distance.cdist(points_coordenada, pontos_coordenada, métrica='euclidiana')def cal_total_distance( rotina):'''O função objetivo. rotina de entrada, retorna a distância total. cal_total_distance(np.arange(num_points)) '''num_points, = rotina.shapereturn sum([distance_matrix[routine[i % num_points], rotina[(i + 1) % num_points]] para i no intervalo(num_points)])
Etapa 2 : faça GA
-> Código de demonstração: exemplos/demo_ga_tsp.py#s2
de 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()
Etapa 3 : plote o resultado:
-> Código de demonstração: exemplos/demo_ga_tsp.py#s3
fig, ax = plt.subplots(1, 2)melhores_pontos_ = np.concatenate([melhores_pontos, [melhores_pontos[0]]])melhores_pontos_coordenada = pontos_coordenada[melhores_pontos_, :]ax[0].plot(melhores_pontos_coordenada[:, 0] , melhores_pontos_coordenadas[:, 1], 'ou')ax[1].plot(ga_tsp.generação_best_Y)plt.show()
Passo 1 : defina seu problema:
-> Código de demonstração: exemplos/demo_pso.py#s1
def demo_func(x):x1, x2, x3 = xreturn x1 ** 2 + (x2 - 0,05) ** 2 + x3 ** 2
Etapa 2 : faça PSO
-> Código de demonstração: exemplos/demo_pso.py#s2
de 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('best_x é ', pso.gbest_x, 'best_y é', pso.gbest_y) Etapa 3 : traçar o resultado
-> Código de demonstração: exemplos/demo_pso.py#s3
importar matplotlib.pyplot como pltplt.plot(pso.gbest_y_hist)plt.show()
Se você precisar de restrição não linear como (x[0] - 1) ** 2 + (x[1] - 0) ** 2 - 0.5 ** 2<=0
Os códigos são assim:
restrição_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]
, restrição_ueq = restrição_ueq) Observe que você pode adicionar mais de uma restrição não linear. Basta adicioná-lo a constraint_ueq
Além disso, temos uma animação:
↑ veja exemplos/demo_pso_ani.py
Passo 1 : defina seu problema
-> Código de demonstração: exemplos/demo_sa.py#s1
função_demo = lambda x: x[0] ** 2 + (x[1] - 0,05) ** 2 + x[2] ** 2
Passo 2 : faça SA
-> Código de demonstração: exemplos/demo_sa.py#s2
de 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('melhor_x:', melhor_x, 'melhor_y', melhor_y) Etapa 3 : traçar o resultado
-> Código de demonstração: exemplos/demo_sa.py#s3
importar matplotlib.pyplot como pltimport pandas como pdplt.plot(pd.DataFrame(sa.best_y_history).cummin(axis=0))plt.show()
Além disso, o scikit-opt fornece 3 tipos de Recozimento Simulado: Rápido, Boltzmann, Cauchy. Veja mais sa
Passo 1 : ah, sim, defina seus problemas. Muito chato copiar esta etapa.
Etapa 2 : FAÇA SA para TSP
-> Código de demonstração: exemplos/demo_sa_tsp.py#s2
de 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 (melhores_pontos))
Etapa 3 : traçar o resultado
-> Código de demonstração: exemplos/demo_sa_tsp.py#s3
de matplotlib.ticker import FormatStrFormatterfig, ax = plt.subplots(1, 2)best_points_ = np.concatenate([best_points, [best_points[0]]])best_points_coordenada = pontos_coordenada[best_points_, :]ax[0].plot(sa_tsp.best_y_history)ax[0].set_xlabel("Iteração")ax[0].set_ylabel("Distância")ax[1].plot(melhor_coordenada_pontos[:, 0], melhor_coordenada_pontos [:, 1], marcador='o', marcadorfacecolor='b', cor='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()Mais: Trace a animação:
↑ veja exemplos/demo_sa_tsp.py
-> Código de demonstração: exemplos/demo_aca_tsp.py#s2
de 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 demonstração: exemplos/demo_ia.py#s2
de 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 rotina:', melhores_pontos, 'melhor_distância:', melhor_distância)-> Código de demonstração: exemplos/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, etapa = 0,5, visual = 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. e Kang, X. (2021). SpecView: estrutura de visualização de espectro de malware com transformação de espectro singular. Transações IEEE sobre Análise Forense e Segurança da Informação, 16, 5093-5107.
Zhen, H., Zhai, H., Ma, W., Zhao, L., Weng, Y., Xu, Y., ... e He, X. (2021). Projeto e testes de gerador de solução de fluxo de potência ideal baseado em aprendizagem por reforço. Relatórios de Energia.
Heinrich, K., Zschech, P., Janiesch, C., & Bonin, M. (2021). As propriedades dos dados do processo são importantes: introdução de redes neurais convolucionais fechadas (GCNN) e redes de atenção de previsão de valor-chave (KVP) para previsão do próximo evento com aprendizado profundo. Sistemas de Apoio à Decisão, 143, 113494.
Tang, HK e Goh, SK (2021). Um novo otimizador meta-heurístico não populacional, inspirado na filosofia de Yi Jing. Pré-impressão do arXiv arXiv:2104.08564.
Wu, G., Li, L., Li, X., Chen, Y., Chen, Z., Qiao, B., ... e Xia, L. (2021). Combinação de eventos sociais em tempo real baseada em incorporação de gráficos para recomendação de EBSNs. Rede mundial de computadores, 1-22.
Pan, X., Zhang, Z., Zhang, H., Wen, Z., Ye, W., Yang, Y., ... e Zhao, X. (2021). Um algoritmo rápido e robusto de identificação de gases de mistura e detecção de concentração baseado em mecanismo de atenção equipado com rede neural recorrente com função de dupla perda. Sensores e Atuadores B: Químico, 342, 129982.
Castella Balcell, M. (2021). Otimização do sistema de manutenção de estação para a turbina eólica offshore flutuante WindCrete.
Zhai, B., Wang, Y., Wang, W. e Wu, B. (2021). Estratégia ideal de controle de limite de velocidade variável em trechos de rodovias sob condições de neblina. Pré-impressão do arXiv arXiv:2107.14406.
Sim, XH (2021). Classificação multi-rótulo em dados localmente lineares: Aplicação à previsão de toxicidade química.
Gebhard, L. (2021). Planejamento de expansão de redes de baixa tensão usando otimização de colônias de formigas Ausbauplanung von Niederspannungsnetzen mithilfe eines Ameisenalgorithmus.
Ma, X., Zhou, H. e Li, Z. (2021). Projeto Ótimo para Interdependências entre Sistemas de Hidrogênio e Energia. Transações IEEE em aplicações industriais.
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., ... e Zhang, G. (2021). Uma nova estrutura baseada em IA para planejamento de trajetória ideal de AoI em redes de sensores sem fio assistidas por UAV. Transações IEEE em comunicações sem fio.
Liu, H., Wen, Z., & Cai, W. (2021, agosto). FastPSO: Rumo a um algoritmo eficiente de inteligência de enxame em GPUs. Na 50ª Conferência Internacional sobre Processamento Paralelo (pp. 1-10).
Mahbub, R. (2020). Algoritmos e técnicas de otimização para resolução de TSP.
Li, J., Chen, T., Lim, K., Chen, L., Khan, SA, Xie, J., & Wang, X. (2019). O aprendizado profundo acelerou a síntese de nanoclusters de ouro. Sistemas Inteligentes Avançados, 1(3), 1900029.
