download de evotorch - download de código fonte evotorch

evotorch

Pitão

0.5.1

Baixar

Bem -vindo ao projeto EVOTORCH! O Evotorch é uma biblioteca de computação evolutiva de código aberto desenvolvido na NNAisense, construído sobre o Pytorch. Consulte a documentação para obter orientações aprofundadas sobre o uso de evotorch e junte-se a nós no Slack para discussões.

Comece instalando o Evotorch:

 pip install evotorch

Com o eVotorch, pode -se resolver vários problemas de otimização, independentemente de serem diferenciáveis (ou seja, permitir a ascendência do gradiente). Entre os tipos de problemas que são solucionáveis com o eVotorch estão:

Problemas de otimização de caixa preta (contínua ou discreta)
Tarefas de aprendizado de reforço
Tarefas de aprendizado supervisionado

Vários algoritmos de computação evolutiva estão disponíveis em Evotorch:

Algoritmos de pesquisa baseados em distribuição:
- PGPE: gradientes de políticas com exploração baseada em parâmetros.
- XNES: Estratégias exponenciais de evolução natural.
- CMA-ES: Estratégias de evolução da adaptação da matriz de covariância.
- SNES: Estratégias separáveis de evolução natural.
- CEM: Método cruzado de entropia.
Algoritmos de pesquisa baseados na população:
- GeneticGorithm: uma implementação de algoritmo genético. Também suporta vários objetivos, caso em que se comporta como NSGA-II .
- Cosyne: Neuroevolução de sinapse cooperativa.
- Mapelites: Arquivo multidimensional de elites fenotípicas

Como todos esses algoritmos são implementados em Pytorch, eles se beneficiam do uso de vetorização e paralelização nas GPUs, acelerando drasticamente a otimização quando as GPUs estão disponíveis. Usando Ray, o EVOTORCH escala esses algoritmos ainda mais, dividindo a carga de trabalho:

Múltiplas CPUs
GPUs múltiplas
Vários computadores em um cluster de raios

Exemplos

Abaixo estão alguns exemplos de código que demonstram a API do EVOTORCH.

Um exemplo de otimização de caixa preta

Qualquer função objetiva definida para trabalhar com Pytorch pode ser usada diretamente com o eVotorch. Uma função objetiva não vetorizada simplesmente recebe uma solução como um tensor de tocha unidimensional e retorna uma aptidão como escalar. Uma função objetiva vetorizada recebe um lote de soluções como um tensor de tocha bidimensional e retorna um tensor de fitness de fitness. O exemplo a seguir demonstra como definir e resolver o problema clássico do Rastrigin.

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

Um exemplo de aprendizado de reforço

O exemplo a seguir demonstra como resolver tarefas de aprendizado de reforço que estão disponíveis na biblioteca de ginástica.

 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 )

Mais exemplos podem ser encontrados aqui.

Como citar

Se você usar o EVOTORCH em sua pesquisa, considere citar nosso artigo.

 @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 }
}