evostra

Evostra: estrategia de evolución para Python

La Estrategia de Evolución (ES) es una técnica de optimización basada en ideas de adaptación y evolución. Puede obtener más información al respecto en https://blog.openai.com/evolution-strategies/

Instalación

Es compatible tanto con python2 como con python3.

Instalar desde la fuente:

$ python setup.py install

Instale la última versión desde el repositorio de git usando pip:

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

Instalar desde PyPI:

$ pip install evostra

(Es posible que necesites usar python3 o pip3 para python3)

Usos de muestra

Un agente de IA aprende a jugar al pájaro flappy usando evostra

Un agente de IA aprendiendo a caminar usando evostra

como usar

Los pesos de entrada del módulo EvolutionStrategy son una lista de matrices (una matriz con cualquier forma para cada capa de la red neuronal), por lo que podemos usar cualquier marco para construir el modelo y simplemente pasar los pesos a ES.

Por ejemplo, podemos usar Keras para construir el modelo y pasar sus pesos a ES, pero aquí usamos el modelo integrado FeedForwardNetwork de Evostra, que es mucho más rápido para nuestro 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 ])

Ahora definimos nuestra función 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

Ahora podemos construir el objeto EvolutionStrategy y ejecutarlo durante algunas iteraciones:

 # 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 )

Aquí está el 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

Ahora tenemos los pesos optimizados y podemos actualizar nuestro modelo:

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

Hacer

• Agregar soporte de distribución a través de la red