Téléchargement evotorch - Téléchargement du code source evotorch

evotorch

Python

0.5.1

Télécharger

Bienvenue dans le projet Evotorch! Evotorch est une bibliothèque de calculs évolutives open source développée chez NNISENSEN, construite au-dessus de Pytorch. Voir la documentation pour des conseils approfondis sur l'utilisation de l'évotorch et rejoignez-nous sur Slack pour des discussions.

Commencez par installer Evotorch:

 pip install evotorch

Avec Evotorch, on peut résoudre divers problèmes d'optimisation, qu'ils soient différenciables (c'est-à-dire permettre une descente de gradient). Parmi les types de problèmes qui sont résolubles avec Evotorch figurent:

Problèmes d'optimisation de la boîte noire (continu ou discret)
Tâches d'apprentissage du renforcement
Tâches d'apprentissage supervisées

Divers algorithmes de calcul évolutif sont disponibles dans Evotorch:

Algorithmes de recherche basés sur la distribution:
- PGPE: gradients de politique avec exploration basée sur les paramètres.
- XNES: Stratégies d'évolution naturelle exponentielle.
- CMA-ES: Stratégies d'évolution de l'adaptation de la matrice de covariance.
- SNES: stratégies d'évolution naturelle séparables.
- CEM: Méthode d'entropie croisée.
Algorithmes de recherche basés sur la population:
- Geneticalgorithme: une implémentation d'algorithme génétique. Prend également en charge plusieurs objectifs, auquel cas il se comporte comme NSGA-II .
- Cosyne: Neuroévolution coopérative Synapse.
- Mapélites: archive multidimensionnelle des élites phénotypiques

Étant donné que tous ces algorithmes sont mis en œuvre dans Pytorch, ils bénéficient de l'utilisation de la vectorisation et de la parallélisation sur les GPU, accélérant considérablement l'optimisation lorsque des GPU sont disponibles. En utilisant le rayon, Evotorch éclate encore ces algorithmes en divisant la charge de travail:

CPU multiples
Plusieurs GPU
plusieurs ordinateurs dans un cluster de rayons

Exemples

Vous trouverez ci-dessous quelques exemples de code qui démontrent l'API de l'évotorch.

Un exemple d'optimisation de la boîte noire

Toute fonction objective définie pour fonctionner avec Pytorch peut être utilisée directement avec Evotorch. Une fonction objective non vectorisée reçoit simplement une solution en tant que tenseur de torche à 1 dimension et renvoie une forme physique en tant que scalaire. Une fonction objective vectorisée reçoit un lot de solutions en tant que tenseur de torche bidimensionnel et renvoie un tenseur à 1 dimension de fitness. L'exemple suivant montre comment définir et résoudre le problème classique du rastregin.

 from evotorch import Problem
from evotorch . algorithms import SNES
from evotorch . logging import StdOutLogger , PandasLogger
import math
import matplotlib . pyplot as plt
import torch


# Declare the objective function
def rastrigin ( x : torch . Tensor ) -> torch . Tensor :
    A = 10
    ( _ , n ) = x . shape
    return A * n + torch . sum (( x ** 2 ) - A * torch . cos ( 2 * math . pi * x ), 1 )


# Declare the problem
problem = Problem (
    "min" ,
    rastrigin ,
    initial_bounds = ( - 5.12 , 5.12 ),
    solution_length = 100 ,
    vectorized = True ,
    # device="cuda:0"  # enable this line if you wish to use GPU
)

# Initialize the SNES algorithm to solve the problem
searcher = SNES ( problem , popsize = 1000 , stdev_init = 10.0 )

# Initialize a standard output logger, and a pandas logger
_ = StdOutLogger ( searcher , interval = 10 )
pandas_logger = PandasLogger ( searcher )

# Run SNES for the specified amount of generations
searcher . run ( 2000 )

# Get the progress of the evolution into a DataFrame with the
# help of the PandasLogger, and then plot the progress.
pandas_frame = pandas_logger . to_dataframe ()
pandas_frame [ "best_eval" ]. plot ()
plt . show ()

Un exemple d'apprentissage du renforcement

L'exemple suivant montre comment résoudre les tâches d'apprentissage du renforcement qui sont disponibles via la bibliothèque de gym.

 from evotorch . algorithms import PGPE
from evotorch . logging import StdOutLogger , PicklingLogger
from evotorch . neuroevolution import GymNE

# Declare the problem to solve
problem = GymNE (
    env = "Humanoid-v4" ,  # Solve the Humanoid-v4 task
    network = "Linear(obs_length, act_length)" ,  # Linear policy
    observation_normalization = True ,  # Normalize the policy inputs
    decrease_rewards_by = 5.0 ,  # Decrease each reward by 5.0
    num_actors = "max" ,  # Use all available CPUs
    # num_actors=4,    # Explicit setting. Use 4 actors.
)

# Instantiate a PGPE algorithm to solve the problem
searcher = PGPE (
    problem ,
    # Base population size
    popsize = 200 ,
    # For each generation, sample more solutions until the
    # number of simulator interactions reaches this threshold
    num_interactions = int ( 200 * 1000 * 0.75 ),
    # Stop re-sampling solutions if the current population size
    # reaches or exceeds this number.
    popsize_max = 3200 ,
    # Learning rates
    center_learning_rate = 0.0075 ,
    stdev_learning_rate = 0.1 ,
    # Radius of the initial search distribution
    radius_init = 0.27 ,
    # Use the ClipUp optimizer with the specified maximum speed
    optimizer = "clipup" ,
    optimizer_config = { "max_speed" : 0.15 },
)

# Instantiate a standard output logger
_ = StdOutLogger ( searcher )

# Optional: Instantiate a logger to pickle and save the results periodically.
# In this example, among the saved results will be the center of the search
# distribution, since we are using PGPE which is distribution-based.
_ = PicklingLogger ( searcher , interval = 10 )

# Run the algorithm for the specified amount of generations
searcher . run ( 500 )

# Get the center point of the search distribution,
# obtain a policy out of that point, and visualize the
# agent using that policy.
center_solution = searcher . status [ "center" ]
trained_policy = problem . make_net ( center_solution )
problem . visualize ( trained_policy )

Plus d'exemples peuvent être trouvés ici.

Comment citer

Si vous utilisez Evotorch dans vos recherches, envisagez de citer notre article.

 @article { evotorch2023arxiv ,
  title = { {EvoTorch}: Scalable Evolutionary Computation in {Python} } ,
  author = { Toklu, Nihat Engin and Atkinson, Timothy and Micka, Vojtv{e}ch and Liskowski, Pawel{} and Srivastava, Rupesh Kumar } ,
  journal = { arXiv preprint } ,
  year = { 2023 } ,
  note = { https://arxiv.org/abs/2302.12600 }
}