adepte est un cadre d'apprentissage par renforcement conçu pour accélérer la recherche en éliminant les défis d'ingénierie associés à l'apprentissage par renforcement profond. adepte fournit :
- formation multi-GPU
- une interface modulaire pour utiliser des réseaux, des agents et des environnements personnalisés
- modèles et algorithmes d'apprentissage par renforcement de base pour PyTorch
- Journalisation Tensorboard intégrée, sauvegarde du modèle, rechargement, évaluation et rendu
- défauts d'hyperparamètres éprouvés
Ce code est en accès anticipé, attendez-vous à des aspérités. Interfaces sujettes à changement. Nous sommes heureux d’accepter les commentaires et les contributions.
En savoir plus
- Installation
- Démarrage rapide
- Caractéristiques
- Performance
Documentation
- Présentation de l'architecture
- Présentation du réseau modulaire
- Reprendre la formation
- Évaluer un modèle
- Environnement de rendu
Exemples
- Réseau personnalisé (stub | exemple)
- Sous-module personnalisé (stub | exemple)
- Agent personnalisé (stub | exemple)
- Environnement personnalisé (stub | exemple)
Installation
git clone https://github.com/heronsystems/adeptRL
cd adeptRL
pip install -e .[all]
Depuis le menu fixe :
- instructions du menu fixe
Démarrage rapide
Former un agent Les journaux vont dans /tmp/adept_logs/
par défaut. Le répertoire des journaux contient le fichier Tensorboard, les modèles enregistrés et d'autres métadonnées.
# 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 >
Utilisez votre propre agent, environnement, réseau ou sous-module
"""
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 ())
- Appelez votre script comme ceci :
python my_script.py --agent MyAgent --env env-id-1 --custom-network MyNet
- Vous pouvez voir tous les arguments ici ou comment implémenter les stubs dans la section exemples ci-dessus.
Caractéristiques
Scripts
Local (un seul nœud, un seul GPU)
- Le meilleur point de départ si vous essayez de comprendre le code.
Distribué (Multi-nœuds, Multi-GPU)
- Utilise le backend NCCL pour réduire entièrement les dégradés sur les GPU sans serveur de paramètres ni processus hôte.
- Prend en charge NVLINK et InfiniBand pour réduire les frais de communication
- InfiniBand n'a pas été testé car nous n'avons pas de configuration sur laquelle tester.
Architectures d'apprenants acteurs pondérés par importance, IMPALA (nœud unique, multi-GPU)
- Notre implémentation utilise des processeurs GPU plutôt que des processeurs CPU pour les passes directes.
- Sur Atari, nous obtenons ~ 4 000 SPS = ~ 16 000 FPS avec deux GPU et un CPU à 8 cœurs.
- "Notez que l'expérience IMPALA peu profonde réalise la formation de plus de 200 millions d'images en moins d'une heure."
- Les expériences officielles IMPALA utilisent 48 cœurs.
- Le nôtre : 2000 images / (deuxième * # cœur de processeur) DeepMind : 1157 images / (deuxième * # cœur de processeur)
- Ne prend pas encore en charge plusieurs nœuds ni les transferts directs de mémoire GPU.
Agents
- Advantage Actor Critic, A2C (papier | code)
- Acteur Critique Vtrace, IMPALA (papier | code)
Réseaux
- Interface réseau modulaire : prend en charge les formes d'entrée et de sortie arbitraires jusqu'à 4D via une API SubModule.
- Réseaux avec état (c'est-à-dire LSTM)
- Normalisation par lots (papier)
Environnements
Performance
- ~ 3 000 pas/seconde = 12 000 FPS (Atari)
- Mode local
- 64 environnements
- GeForce 2080Ti
- Ryzen 2700x 8 cœurs
- Utilisé pour gagner un concours Doom (Ben Bell / Marv2in)
- Formé pour 50 millions de pas / 200 millions d'images
- Jusqu'à 30 no-ops au début de chaque épisode
- Évalué sur des graines différentes de celles formées sur
- Architecture : Quatre Convs (F=32) suivis d'un LSTM (F=512)
- Reproduire avec
python -m adept.app local --logdir ~/local64_benchmark --eval -y --nb-step 50e6 --env <env-id>
Remerciements
Nous empruntons des morceaux du code gym et des lignes de base d'OpenAI. Nous indiquons où cela se fait.