evostra

Evostra: Estratégia de Evolução para Python

Estratégia de Evolução (ES) é uma técnica de otimização baseada em ideias de adaptação e evolução. Você pode aprender mais sobre isso em https://blog.openai.com/evolution-strategies/

Instalação

É compatível com python2 e python3.

Instalar da fonte:

$ python setup.py install

Instale a versão mais recente do repositório git usando pip:

$ pip install git+https://github.com/alirezamika/evostra.git

Instale a partir do PyPI:

$ pip install evostra

(Pode ser necessário usar python3 ou pip3 para python3)

Exemplos de uso

Um agente de IA aprendendo a brincar de flappy bird usando evostra

Um agente de IA aprendendo a andar usando evostra

Como usar

Os pesos de entrada do módulo EvolutionStrategy são uma lista de arrays (um array com qualquer formato para cada camada da rede neural), então podemos usar qualquer framework para construir o modelo e apenas passar os pesos para o ES.

Por exemplo, podemos usar Keras para construir o modelo e passar seus pesos para ES, mas aqui usamos o modelo integrado FeedForwardNetwork da Evostra, que é muito mais rápido para nosso caso de uso:

 import numpy as np
from evostra import EvolutionStrategy
from evostra . models import FeedForwardNetwork

# A feed forward neural network with input size of 5, two hidden layers of size 4 and output of size 3
model = FeedForwardNetwork ( layer_sizes = [ 5 , 4 , 4 , 3 ])

Agora definimos nossa função get_reward:

 solution = np . array ([ 0.1 , - 0.4 , 0.5 ])
inp = np . asarray ([ 1 , 2 , 3 , 4 , 5 ])

def get_reward ( weights ):
    global solution , model , inp
    model . set_weights ( weights )
    prediction = model . predict ( inp )
    # here our best reward is zero
    reward = - np . sum ( np . square ( solution - prediction ))
    return reward

Agora podemos construir o objeto EvolutionStrategy e executá-lo para algumas iterações:

 # if your task is computationally expensive, you can use num_threads > 1 to use multiple processes;
# if you set num_threads=-1, it will use number of cores available on the machine; Here we use 1 process as the
#  task is not computationally expensive and using more processes would decrease the performance due to the IPC overhead.
es = EvolutionStrategy ( model . get_weights (), get_reward , population_size = 20 , sigma = 0.1 , learning_rate = 0.03 , decay = 0.995 , num_threads = 1 )
es . run ( 1000 , print_step = 100 )

Aqui está o resultado:

 iter 100. recompensa: -68,819312
iter 200. recompensa: -0,218466
iter 300. recompensa: -0,110204
iter 400. recompensa: -0,001901
iter 500. recompensa: -0,000459
iter 600. recompensa: -0,000287
iter 700. recompensa: -0,000939
iter 800. recompensa: -0,000504
iter 900. recompensa: -0,000522
iter 1000. recompensa: -0,000178

Agora temos os pesos otimizados e podemos atualizar nosso modelo:

 optimized_weights = es . get_weights ()
model . set_weights ( optimized_weights )

Pendência

• Adicione suporte de distribuição pela rede