d3rlpy

D3RLPY: une bibliothèque d'apprentissage en renforcement profond hors ligne

D3RLPY est une bibliothèque d'apprentissage en renforcement profonde hors ligne pour les praticiens et les chercheurs.

 import d3rlpy

dataset , env = d3rlpy . datasets . get_dataset ( "hopper-medium-v0" )

# prepare algorithm
sac = d3rlpy . algos . SACConfig ( compile_graph = True ). create ( device = "cuda:0" )

# train offline
sac . fit ( dataset , n_steps = 1000000 )

# train online
sac . fit_online ( env , n_steps = 1000000 )

# ready to control
actions = sac . predict ( x )

• Documentation: https://d3rlpy.readthedocs.io
• Papier: https://arxiv.org/abs/2111.03788

Important

V2.xx introduit des changements de rupture. Si vous vous en tenez toujours à v1.xx, veuillez installer explicitement les versions précédentes (par exemple pip install d3rlpy==1.1.1 ).

Caractéristiques clés

⚡ Bibliothèque RL la plus pratique de tous les temps

• RL Offline : D3RLPY prend en charge les algorithmes RL hors ligne de pointe. RL Offline est extrêmement puissant lorsque l'interaction en ligne n'est pas possible pendant la formation (par exemple, la robotique, médical).
• RL en ligne : D3RLPY prend également en charge les algorithmes de formation en ligne de pointe conventionnels sans aucun compromis, ce qui signifie que vous pouvez résoudre tout type de problèmes RL uniquement avec d3rlpy .

? API conviviale

• Zero-Knowledge of DL Library : D3RLPY fournit de nombreux algorithmes de pointe via des API intuitives. Vous pouvez devenir ingénieur RL même sans savoir utiliser des bibliothèques d'apprentissage en profondeur.
• Documentation étendue : D3RLPY est entièrement documenté et accompagné de tutoriels et de scripts de reproduction des articles originaux.

Au-delà de l'état de la technologie

• Distributional Q Fonction : D3RLPY est la première bibliothèque qui prend en charge les fonctions Q distributionnelles dans tous les algorithmes. La fonction de distribution Q est connue comme la méthode très puissante pour atteindre l'état de la performance.
• Formation distribuée de données-pré-prête : D3RLPY est la première bibliothèque qui prend en charge la formation RL hors ligne distribuée parallèle aux données, ce qui vous permet d'équilibrer RL hors ligne avec plusieurs GPU ou nœuds. Voir l'exemple.

Installation

D3RLPY prend en charge Linux, MacOS et Windows.

Dépendances

L'installation du package D3RLPY installe ou mettra à niveau les packages suivants pour satisfaire aux exigences:

• torch> = 2.5.0
• tqdm> = 4,66.3
• Gym> = 0,26.0
• gymnase> = 1.0.0
• faire un clic
• Colorama
• Dataclasses-json
• h5py
• structure
• Taping-Extensions
• scikit-apprend

PYPI (recommandé)

 $ pip install d3rlpy

Anaconda

 $ conda install conda-forge/noarch::d3rlpy

Docker

 $ docker run -it --gpus all --name d3rlpy takuseno/d3rlpy:latest bash

Algorithmes pris en charge

algorithme	contrôle discret	contrôle continu
Cloning de comportement (apprentissage supervisé)	✅	✅
I itération Q ajustée neuronale (NFQ)	✅	⛔
Network Q (DQN)	✅	⛔
DQN double	✅	⛔
Gradients de politique déterministe profonde (DDPG)	⛔	✅
Twin retardé des gradients de politique déterministe profonde (TD3)	⛔	✅
Acteur doux-critique (sac)	✅	✅
Lot-learning contrainte par lots (BCQ)	✅	✅
Réduction d'accumulation d'erreur d'amorçage (ours)	⛔	✅
Learning Q-Learning (CQL) conservateur	✅	✅
Avantage Acteur-critique (AWAC)	⛔	✅
Régression critique de la critique (CRR)	⛔	✅
Politique dans l'espace d'action latente (PLAS)	⛔	✅
TD3 + BC	⛔	✅
Réglialisation des politiques avec contrainte de jeu de données (PRDC)	⛔	✅
Implicit Q-Learning (IQL)	⛔	✅
Learning Q calibré (CAL-QL)	⛔	✅
Renommer	⛔	✅
Transformateur de décision	✅	✅
Gato	?	?

Fonctions Q prise en charge

• Fonction Q standard
• Régression quantile
• Réseau quantile implicite

Résultats de référence

D3RLPY est comparé pour assurer la qualité de la mise en œuvre. Les scripts de référence sont le répertoire des reproductions disponibles. Les résultats de référence sont disponibles le référentiel D3Rlpy-Benchmarks.

Exemples

Mujoco

 import d3rlpy

# prepare dataset
dataset , env = d3rlpy . datasets . get_d4rl ( 'hopper-medium-v0' )

# prepare algorithm
cql = d3rlpy . algos . CQLConfig ( compile_graph = True ). create ( device = 'cuda:0' )

# train
cql . fit (
    dataset ,
    n_steps = 100000 ,
    evaluators = { "environment" : d3rlpy . metrics . EnvironmentEvaluator ( env )},
)

Voir plus d'ensembles de données sur D4RL.

Atari 2600

 import d3rlpy

# prepare dataset (1% dataset)
dataset , env = d3rlpy . datasets . get_atari_transitions (
    'breakout' ,
    fraction = 0.01 ,
    num_stack = 4 ,
)

# prepare algorithm
cql = d3rlpy . algos . DiscreteCQLConfig (
    observation_scaler = d3rlpy . preprocessing . PixelObservationScaler (),
    reward_scaler = d3rlpy . preprocessing . ClipRewardScaler ( - 1.0 , 1.0 ),
    compile_graph = True ,
). create ( device = 'cuda:0' )

# start training
cql . fit (
    dataset ,
    n_steps = 1000000 ,
    evaluators = { "environment" : d3rlpy . metrics . EnvironmentEvaluator ( env , epsilon = 0.001 )},
)

Voir plus de jeux de données Atari à D4RL-ATARI.

Formation en ligne

 import d3rlpy
import gym

# prepare environment
env = gym . make ( 'Hopper-v3' )
eval_env = gym . make ( 'Hopper-v3' )

# prepare algorithm
sac = d3rlpy . algos . SACConfig ( compile_graph = True ). create ( device = 'cuda:0' )

# prepare replay buffer
buffer = d3rlpy . dataset . create_fifo_replay_buffer ( limit = 1000000 , env = env )

# start training
sac . fit_online ( env , buffer , n_steps = 1000000 , eval_env = eval_env )

Tutoriels

Essayez des exemples de Cartpole sur Google Colaboratory!

• tutoriel RL hors ligne:
• Tutoriel RL en ligne:

Plus de documents de tutoriel sont disponibles ici.

Contributions

Tout type de contribution à D3Rlpy serait très apprécié! Veuillez vérifier le guide de contribution.

Communauté

Canal	Lien
Problèmes	Problèmes de github

Important

Veuillez ne pas envoyer de courriel à aucun contributeur, y compris le propriétaire de ce projet, de demander un support technique. Ces e-mails seront ignorés sans répondre à votre message. Utilisez des problèmes GitHub pour signaler vos problèmes.

Projets utilisant d3rlpy

Projet	Description
Mineroir	Un outil d'interface graphique prêt à l'emploi pour RL hors ligne
Portée-rl	Une bibliothèque d'évaluation et de sélection hors politique

Feuille de route

La feuille de route vers la future version est disponible dans la feuille de route.md.

Citation

Le papier est disponible ici.

 @article{d3rlpy,
  author  = {Takuma Seno and Michita Imai},
  title   = {d3rlpy: An Offline Deep Reinforcement Learning Library},
  journal = {Journal of Machine Learning Research},
  year    = {2022},
  volume  = {23},
  number  = {315},
  pages   = {1--20},
  url     = {http://jmlr.org/papers/v23/22-0017.html}
}

Reconnaissance

Ce travail a commencé dans le cadre du projet de doctorat de Takuma Seno à l'Université Keio en 2020.

Ce travail est étayé par l'agence de promotion de l'information-technologie de l'information, Japon (IPA), Exploratory IT Human Resources Project (programme MITOU) au cours de l'exercice 2020.