baselines
1.0.0
Statut : Maintenance (attendez-vous à des corrections de bugs et à des mises à jour mineures)
OpenAI Baselines est un ensemble d'implémentations de haute qualité d'algorithmes d'apprentissage par renforcement.
Ces algorithmes permettront à la communauté des chercheurs de reproduire, d’affiner et d’identifier plus facilement de nouvelles idées, et créeront de bonnes bases de référence sur lesquelles élaborer la recherche. Notre implémentation DQN et ses variantes sont à peu près comparables aux scores des articles publiés. Nous espérons qu'ils serviront de base autour de laquelle de nouvelles idées pourront être ajoutées et d'outil permettant de comparer une nouvelle approche à celles existantes.
Les lignes de base nécessitent python3 (>=3,5) avec les en-têtes de développement. Vous aurez également besoin des packages système CMake, OpenMPI et zlib. Ceux-ci peuvent être installés comme suit
sudo apt-get update && sudo apt-get install cmake libopenmpi-dev python3-dev zlib1g-devL'installation des packages système sur Mac nécessite Homebrew. Une fois Homebrew installé, exécutez ce qui suit :
brew install cmake openmpiDu point de vue général de la santé des packages Python, c'est une bonne idée d'utiliser des environnements virtuels (virtualenvs) pour s'assurer que les packages de différents projets n'interfèrent pas les uns avec les autres. Vous pouvez installer virtualenv (qui est lui-même un package pip) via
pip install virtualenvLes Virtualenvs sont essentiellement des dossiers contenant des copies de l'exécutable Python et de tous les packages Python. Pour créer un virtualenv appelé venv avec python3, on exécute
virtualenv /path/to/venv --python=python3Pour activer un virtualenv :
. /path/to/venv/bin/activate
Un tutoriel plus complet sur les virtualenvs et les options peut être trouvé ici
La branche principale prend en charge Tensorflow de la version 1.4 à 1.14. Pour la prise en charge de Tensorflow 2.0, veuillez utiliser la branche tf2.
Clonez le dépôt et cd-y :
git clone https://github.com/openai/baselines.git
cd baselinesSi TensorFlow n'est pas déjà installé, installez votre version préférée de TensorFlow. Dans la plupart des cas, vous pouvez utiliser
pip install tensorflow-gpu==1.14 # if you have a CUDA-compatible gpu and proper driversou
pip install tensorflow==1.14pour installer Tensorflow 1.14, qui est la dernière version de Tensorflow prise en charge par la branche principale. Reportez-vous au guide d'installation de TensorFlow pour plus de détails.
Installer le package de lignes de base
pip install -e .Certains des exemples de base utilisent le simulateur physique MuJoCo (multi-joint Dynamics in Contact), qui est propriétaire et nécessite des binaires et une licence (une licence temporaire de 30 jours peut être obtenue sur www.mujoco.org). Les instructions sur la configuration de MuJoCo peuvent être trouvées ici
Tous les tests unitaires des lignes de base peuvent être exécutés à l'aide de pytest runner :
pip install pytest
pytest
La plupart des algorithmes du dépôt de référence sont utilisés comme suit :
python -m baselines.run --alg= < name of the algorithm > --env= < environment_id > [additional arguments]Par exemple, pour former un réseau entièrement connecté contrôlant l'humanoïde MuJoCo à l'aide de PPO2 pendant 20 millions de temps
python -m baselines.run --alg=ppo2 --env=Humanoid-v2 --network=mlp --num_timesteps=2e7 Notez que pour les environnements mujoco, le réseau entièrement connecté est par défaut, nous pouvons donc omettre --network=mlp Les hyperparamètres du réseau et de l'algorithme d'apprentissage peuvent être contrôlés via la ligne de commande, par exemple :
python -m baselines.run --alg=ppo2 --env=Humanoid-v2 --network=mlp --num_timesteps=2e7 --ent_coef=0.1 --num_hidden=32 --num_layers=3 --value_network=copyfixera le coefficient d'entropie à 0,1 et construira un réseau entièrement connecté avec 3 couches avec 32 unités cachées dans chacune, et créera un réseau séparé pour l'estimation de la fonction de valeur (afin que ses paramètres ne soient pas partagés avec le réseau politique, mais que la structure soit la même )
Voir docstrings dans common/models.py pour la description des paramètres réseau pour chaque type de modèle, et docstring pour baselines/ppo2/ppo2.py/learn() pour la description des hyperparamètres ppo2.
DQN avec Atari est à ce stade un classique des benchmarks. Pour exécuter l’implémentation de base de DQN sur Atari Pong :
python -m baselines.run --alg=deepq --env=PongNoFrameskip-v4 --num_timesteps=1e6
L'API de sérialisation des algorithmes n'est pas encore correctement unifiée ; cependant, il existe une méthode simple pour sauvegarder/restaurer les modèles entraînés. Les options de ligne de commande --save_path et --load_path chargent l'état tensorflow à partir d'un chemin donné avant l'entraînement et l'enregistrent après l'entraînement, respectivement. Imaginons que vous souhaitiez entraîner ppo2 sur Atari Pong, sauvegarder le modèle et visualiser plus tard ce qu'il a appris.
python -m baselines.run --alg=ppo2 --env=PongNoFrameskip-v4 --num_timesteps=2e7 --save_path= ~ /models/pong_20M_ppo2Cela devrait atteindre la récompense moyenne par épisode d'environ 20. Pour charger et visualiser le modèle, nous allons procéder comme suit : charger le modèle, l'entraîner pendant 0 étape, puis visualiser :
python -m baselines.run --alg=ppo2 --env=PongNoFrameskip-v4 --num_timesteps=0 --load_path= ~ /models/pong_20M_ppo2 --playREMARQUE : les environnements Mujoco nécessitent une normalisation pour fonctionner correctement, nous les enveloppons donc avec le wrapper VecNormalize. Actuellement, pour garantir que les modèles sont enregistrés avec normalisation (afin que les modèles entraînés puissent être restaurés et exécutés sans formation supplémentaire), les coefficients de normalisation sont enregistrés en tant que variables Tensorflow. Cela peut diminuer quelque peu les performances, donc si vous avez besoin d'étapes à haut débit avec Mujoco et que vous n'avez pas besoin de sauvegarder/restaurer les modèles, il peut être judicieux d'utiliser la normalisation numpy à la place. Pour ce faire, définissez 'use_tf=False` dans baselines/run.py.
Par défaut, toutes les données récapitulatives, y compris la progression et la sortie standard, sont enregistrées dans un répertoire unique dans un dossier temporaire, spécifié par un appel au tempfile.gettempdir() de Python. Le répertoire peut être modifié avec l'option de ligne de commande --log_path .
python -m baselines.run --alg=ppo2 --env=PongNoFrameskip-v4 --num_timesteps=2e7 --save_path= ~ /models/pong_20M_ppo2 --log_path= ~ /logs/Pong/REMARQUE : Sachez que l'enregistreur écrasera les fichiers du même nom dans un répertoire existant. Il est donc recommandé de donner aux noms de dossiers un horodatage unique pour éviter l'écrasement des journaux.
Une autre façon de modifier le répertoire temporaire consiste à utiliser la variable d'environnement $OPENAI_LOGDIR .
Pour des exemples sur la façon de charger et d'afficher les données d'entraînement, voir ici.
Les résultats des benchmarks sur Mujoco (pas de temps de 1 million) et Atari (pas de temps de 10 millions) sont disponibles ici pour Mujoco et ici pour Atari respectivement. Notez que ces résultats peuvent ne pas figurer sur la dernière version du code, le hachage de validation particulier avec lequel les résultats ont été obtenus est spécifié sur la page des tests de performance.
Pour citer ce référentiel dans les publications :
@misc{baselines,
author = {Dhariwal, Prafulla and Hesse, Christopher and Klimov, Oleg and Nichol, Alex and Plappert, Matthias and Radford, Alec and Schulman, John and Sidor, Szymon and Wu, Yuhuai and Zhokhov, Peter},
title = {OpenAI Baselines},
year = {2017},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {url{https://github.com/openai/baselines}},
}
