adeptRL

adept é uma estrutura de aprendizagem por reforço projetada para acelerar a pesquisa, abstraindo os desafios de engenharia associados à aprendizagem por reforço profundo. adepto fornece:

• treinamento multi-GPU
• uma interface modular para usar redes, agentes e ambientes personalizados
• modelos e algoritmos de aprendizagem por reforço de linha de base para PyTorch
• registro de tensorboard integrado, salvamento de modelo, recarga, avaliação e renderização
• padrões comprovados de hiperparâmetros

Este código é de acesso antecipado, espere arestas. Interfaces sujeitas a alterações. Estamos felizes em aceitar comentários e contribuições.

Leia mais

• Instalação
• Início rápido
• Características
• Desempenho

Documentação

• Visão geral da arquitetura
• Visão geral da rede modular
• Retomar o treinamento
• Avalie um modelo
• Ambiente de renderização

Exemplos

• Rede personalizada (esboço | exemplo)
• Submódulo personalizado (esboço | exemplo)
• Agente personalizado (esboço | exemplo)
• Ambiente personalizado (esboço | exemplo)

Instalação

git clone https://github.com/heronsystems/adeptRL
cd adeptRL
pip install -e .[all]

Da janela de encaixe:

• instruções do docker

Início rápido

Os logs de treinamento de um agente vão para /tmp/adept_logs/ por padrão. O diretório log contém o arquivo tensorboard, modelos salvos e outros metadados.

 # Local Mode (A2C)
# We recommend 4GB+ GPU memory, 8GB+ RAM, 4+ Cores
python -m adept.app local --env BeamRiderNoFrameskip-v4

# Distributed Mode (A2C, requires NCCL)
# We recommend 2+ GPUs, 8GB+ GPU memory, 32GB+ RAM, 4+ Cores
python -m adept.app distrib --env BeamRiderNoFrameskip-v4

# IMPALA (requires ray, resource intensive)
# We recommend 2+ GPUs, 8GB+ GPU memory, 32GB+ RAM, 4+ Cores
python -m adept.app actorlearner --env BeamRiderNoFrameskip-v4

# To see a full list of options:
python -m adept.app -h
python -m adept.app help < command >

Use seu próprio agente, ambiente, rede ou submódulo

 """
my_script.py

Train an agent on a single GPU.
"""
from adept . scripts . local import parse_args , main
from adept . network import NetworkModule , SubModule1D
from adept . agent import AgentModule
from adept . env import EnvModule


class MyAgent ( AgentModule ):
    pass  # Implement


class MyEnv ( EnvModule ):
    pass  # Implement


class MyNet ( NetworkModule ):
    pass  # Implement


class MySubModule1D ( SubModule1D ):
    pass  # Implement


if __name__ == '__main__' :
    import adept
    adept . register_agent ( MyAgent )
    adept . register_env ( MyEnv )
    adept . register_network ( MyNet )
    adept . register_submodule ( MySubModule1D )
    main ( parse_args ())

• Chame seu script assim: python my_script.py --agent MyAgent --env env-id-1 --custom-network MyNet
• Você pode ver todos os argumentos aqui ou como implementar os stubs na seção de exemplos acima.

Características

Roteiros

Local (nó único, GPU único)

• Melhor lugar para começar se você estiver tentando entender o código.

Distribuído (multinó, multi-GPU)

• Usa back-end NCCL para reduzir totalmente os gradientes em GPUs sem um servidor de parâmetros ou processo host.
• Suporta NVLINK e InfiniBand para reduzir a sobrecarga de comunicação
• InfiniBand não testado porque não temos uma configuração para testar.

Arquiteturas de Aprendizagem de Ator Ponderadas por Importância, IMPALA (Nó Único, Multi-GPU)

• Nossa implementação usa trabalhadores de GPU em vez de trabalhadores de CPU para avanços.
• No Atari alcançamos ~4k SPS = ~16k FPS com duas GPUs e uma CPU de 8 núcleos.
• “Observe que o experimento IMPALA superficial completa o treinamento de mais de 200 milhões de quadros em menos de uma hora.”
• Os experimentos oficiais do IMPALA usam 48 núcleos.
• Nosso: 2.000 quadros / (segundo * # núcleo da CPU) DeepMind: 1157 quadros / (segundo * # núcleo da CPU)
• Ainda não oferece suporte a vários nós ou transferências diretas de memória de GPU.

Agentes

• Advantage Actor Critic, A2C (artigo | código)
• Ator Crítico Vtrace, IMPALA (artigo | código)

Redes

• Interface de rede modular: suporta formas arbitrárias de entrada e saída até 4D por meio de uma API SubModule.
• Redes com estado (ou seja, LSTMs)
• Normalização em lote (papel)

Ambientes

• OpenAI Ginásio Atari

Desempenho

• ~ 3.000 passos/segundo = 12.000 FPS (Atari)
  • Modo Local
  • 64 ambientes
  • GeForce 2080Ti
  • Ryzen 2700x 8 núcleos
• Usado para vencer uma competição Doom (Ben Bell / Marv2in)
• Treinado para passos de 50M/quadros de 200M
• Até 30 no-ops no início de cada episódio
• Avaliado em sementes diferentes daquelas treinadas
• Arquitetura: Quatro Convs (F=32) seguido por um LSTM (F=512)
• Reproduza com python -m adept.app local --logdir ~/local64_benchmark --eval -y --nb-step 50e6 --env <env-id>

Agradecimentos

Pegamos emprestados pedaços do código de ginásio e de linha de base da OpenAI. Indicamos onde isso é feito.