adeptRL

adept es un marco de aprendizaje por refuerzo diseñado para acelerar la investigación abstrayendo los desafíos de ingeniería asociados con el aprendizaje por refuerzo profundo. adepto proporciona:

• entrenamiento multi-GPU
• una interfaz modular para usar redes, agentes y entornos personalizados
• Modelos y algoritmos de aprendizaje por refuerzo de referencia para PyTorch.
• registro integrado de tensorboard, guardado de modelos, recarga, evaluación y renderizado
• valores predeterminados de hiperparámetros probados

Este código es de acceso temprano, espere algunas asperezas. Interfaces sujetas a cambios. Estaremos encantados de aceptar comentarios y contribuciones.

Leer más

• Instalación
• Inicio rápido
• Características
• Actuación

Documentación

• Descripción general de la arquitectura
• Descripción general de la red modular
• Reanudar el entrenamiento
• Evaluar un modelo
• Entorno de renderizado

Ejemplos

• Red personalizada (stub | ejemplo)
• Submódulo personalizado (stub | ejemplo)
• Agente personalizado (stub | ejemplo)
• Entorno personalizado (stub | ejemplo)

Instalación

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

Desde la ventana acoplable:

• instrucciones de la ventana acoplable

Inicio rápido

Los registros de capacitación de un agente van a /tmp/adept_logs/ de forma predeterminada. El directorio de registro contiene el archivo tensorboard, los modelos guardados y otros metadatos.

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

Utilice su propio agente, entorno, red o 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 ())

• Llame a su script de esta manera: python my_script.py --agent MyAgent --env env-id-1 --custom-network MyNet
• Puede ver todos los argumentos aquí o cómo implementar los resguardos en la sección de ejemplos anterior.

Características

Guiones

Local (nodo único, GPU única)

• El mejor lugar para comenzar si intentas comprender el código.

Distribuido (multinodo, multi-GPU)

• Utiliza el backend NCCL para reducir completamente los gradientes en las GPU sin un servidor de parámetros ni un proceso de host.
• Admite NVLINK e InfiniBand para reducir la sobrecarga de comunicación
• InfiniBand no se ha probado ya que no tenemos una configuración para realizar pruebas.

Arquitecturas de aprendizaje de actores ponderados por importancia, IMPALA (nodo único, GPU múltiple)

• Nuestra implementación utiliza trabajadores de GPU en lugar de trabajadores de CPU para los pases hacia adelante.
• En Atari logramos ~4k SPS = ~16k FPS con dos GPU y una CPU de 8 núcleos.
• "Tenga en cuenta que el experimento superficial IMPALA completa el entrenamiento de más de 200 millones de fotogramas en menos de una hora".
• Los experimentos oficiales de IMPALA utilizan 48 núcleos.
• Nuestro: 2000 cuadros / (segundo * # núcleo de CPU) DeepMind: 1157 cuadros / (segundo * # núcleo de CPU)
• Aún no admite múltiples nodos ni transferencias directas de memoria de GPU.

Agentes

• Crítico de actor de ventaja, A2C (artículo | código)
• Actor Crítico Vtrace, IMPALA (papel | código)

Redes

• Interfaz de red modular: admite formas de entrada y salida arbitrarias hasta 4D a través de una API SubModule.
• Redes con estado (es decir, LSTM)
• Normalización por lotes (papel)

Ambientes

• Gimnasio OpenAI Atari

Actuación

• ~ 3000 pasos/segundo = 12 000 FPS (Atari)
  • Modo local
  • 64 ambientes
  • GeForce 2080Ti
  • Ryzen 2700x de 8 núcleos
• Solía ​​​​ganar una competencia de Doom (Ben Bell / Marv2in)
• Entrenado para pasos de 50 m / fotogramas de 200 m
• Hasta 30 no operaciones al inicio de cada episodio.
• Evaluado en semillas diferentes a las entrenadas
• Arquitectura: Cuatro Convs (F=32) seguidas de un LSTM (F=512)
• Reproducir con python -m adept.app local --logdir ~/local64_benchmark --eval -y --nb-step 50e6 --env <env-id>

Expresiones de gratitud

Tomamos prestados fragmentos del código de líneas de base y gimnasio de OpenAI. Indicamos dónde se hace esto.