Algoritmos artificialmente inteligentes para otimização em Python

Seguindo os artigos anteriores sobre interfaces (+) e (exatas) solucionadores (+) para otimização em Python, neste artigo, introduzoalguns pacotes que fornecem uma “interface” fácil de usar para algoritmos artificialmente inteligentes (AIAs) (por exemplo, heurística, meta-heurística, matemática-heurística, learn-heuristics ou hiper-heurística).

As AIAs podem não alcançar soluções globalmente ideais, o que significa que o usuário deve estar sempre ciente da razão para escolhê-las com base em um caso de uso e tentar ajustar seus parâmetros ou aumentar sua adaptabilidade à paisagem de um problema de otimização. No entanto, ao contrário dos solucionadores (exatos) introduzidos, eles podem obter soluções em um período razoavelmente
menor de tempo. Além disso, as AIAs podem não derivar soluções viáveis com base nas características de um modelo de otimização (e na experiência de programação do usuário). A vantagem significativa do
uso de um AIA é que não importa as características do problema de otimização (por exemplo, LP, MIP, MILP ou MINLP), um AIA pode ser um solucionador de problemas geral (GPS) e resolver todos eles.

Notavelmente, este não é um levantamento completo do que está disponível, mas vou tentar completá-lo ao longo do tempo. Além disso, implemento ga ou PSO através dos pacotes introduzidos, dois dos AIAs mais famosos introduzidos em 1975 e 1995. Por isso, os pacotes introduzidos também devem apoiá-los. Por fim, como o modelo de otimização é apresentado aqui (+) e tem restrições, eu as modelo como penalidades na função objetiva.

1. GeneticAlgorithm para otimização em Python

  • Github
  • Pacote
  • Algoritmos suportados: GA.
  • Apoio a múltiplos objetivos: Não.

Aqui, eu forneço um exemplo de codificação usando “geneticalgorithm” em Python:

import numpy as np
from geneticalgorithm import geneticalgorithm as ga

varbound=np.array([[0,1],[0,1]])
vartype=np.array([['real'],['real']])

algorithm_param = {'max_num_iteration': 100,\
                   'population_size':60,\
                   'mutation_probability':0.1,\
                   'elit_ratio': 0.01,\
                   'crossover_probability': 0.5,\
                   'parents_portion': 0.3,\
                   'crossover_type':'uniform',\
                   'max_iteration_without_improv':None}  
    
def MyOptProb(X):
    y = 0+X[1]*(1.29-0)
    x = np.round(0+X[0]*(2-0))
    g1 = 5/10 * x + 3/10 * y - 1
    g2 = 2/9 * x + 7/9 * y - 1
    penalty = np.amax(np.array([0,g1,g2]))
    return -(2*x+5*y)+150*penalty**2

def Results(obj, variables):
    x = round(0+variables[0]*(2-0))
    y = 0+variables[0]*(1.29-0)
    g1 = 5 * x + 3 * y - 10
    g2 = 2 * x + 7 * y - 9
    print(g1)
    print(g2)
    if g1>10e-6 or g2>10e-6:
      print("infeasible")
    else:
      print("feasible")
    print("x:",x)
    print("y:",y)
    print("obj:",2*x+5*y)

model=ga(function=MyOptProb,dimension=2,variable_type_mixed=vartype,variable_boundaries=varbound,algorithm_parameters=algorithm_param)
model.run()
   
Results(model.best_function,model.best_variable)

2. PYSWARMS para otimização em Python

  • Github
  • Pacote
  • Algoritmos suportados: PSO.
  • Suporte a múltiplos objetivos: Não

Aqui, eu forneci um exemplo de codificação usando “pyswarms” em Python:

from pyswarms.single.global_best import GlobalBestPSO
import numpy as np

x_min = [0, 0]
x_max = [1, 1]
bounds = (x_min, x_max)
dim = len(x_min)

pop = 100
iterations = 250
options = {'c1': 0.5, 'c2': 0.4, 'w': 0.9}

def MyOptProb(x):
    y = 0 + x[:, 1] * (1.29 - 0)
    x = np.round(0 + x[:, 0] * (2 - 0))
    g1 = 5 / 10 * x + 3 / 10 * y - 1
    g2 = 2 / 9 * x + 7 / 9 * y - 1
    penalty = np.amax(np.array([np.zeros(pop), g1, g2]))
    return -(2 * x + 5 * y) + 150 * penalty ** 2

def Results(obj, variables):
    x = round(0 + variables[0] * (2 - 0))
    y = 0 + variables[0] * (1.29 - 0)
    g1 = 5 * x + 3 * y - 10
    g2 = 2 * x + 7 * y - 9
    if g1 > 10e-6 or g2 > 10e-6:
        print ('infeasible')
    else:
        print ('feasible')
    print ('x:', x)
    print ('y:', y)
    print ('obj:', 2 * x + 5 * y)

optimizer = GlobalBestPSO(n_particles=pop, dimensions=dim,
                          options=options, bounds=bounds)
(obj, variables) = optimizer.optimize(MyOptProb, iterations)

Results(obj, variables)

Leave a Reply

Deixe um comentário

O seu endereço de e-mail não será publicado.

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.

Close

Meta