evostra

Evostra : stratégie d'évolution pour Python

La stratégie d'évolution (ES) est une technique d'optimisation basée sur des idées d'adaptation et d'évolution. Vous pouvez en savoir plus sur https://blog.openai.com/evolution-strategies/

Installation

Il est compatible avec python2 et python3.

Installer à partir des sources :

$ python setup.py install

Installez la dernière version du référentiel git à l'aide de pip :

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

Installer depuis PyPI :

$ pip install evostra

(Vous devrez peut-être utiliser python3 ou pip3 pour python3)

Exemples d'utilisation

Un agent IA apprend à jouer à Flappy Bird avec evostra

Un agent IA apprend à marcher avec evostra

Comment utiliser

Les poids d'entrée du module EvolutionStrategy sont une liste de tableaux (un tableau avec n'importe quelle forme pour chaque couche du réseau neuronal), nous pouvons donc utiliser n'importe quel framework pour construire le modèle et simplement transmettre les poids à ES.

Par exemple, nous pouvons utiliser Keras pour construire le modèle et transmettre ses pondérations à ES, mais ici nous utilisons le modèle intégré d'Evostra, FeedForwardNetwork, qui est beaucoup plus rapide pour notre cas d'utilisation :

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

Nous définissons maintenant notre fonction 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

Nous pouvons maintenant créer l'objet EvolutionStrategy et l'exécuter pendant quelques itérations :

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

Voici le résultat :

 iter 100. récompense : -68.819312
iter 200. récompense : -0,218466
iter 300. récompense : -0,110204
iter 400. récompense : -0,001901
iter 500. récompense : -0,000459
iter 600. récompense : -0,000287
iter 700. récompense : -0,000939
iter 800. récompense : -0,000504
iter 900. récompense : -0,000522
iter 1000. récompense : -0,000178

Nous avons maintenant les poids optimisés et nous pouvons mettre à jour notre modèle :

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

Faire

• Ajouter la prise en charge de la distribution sur le réseau