tianshou
v1.1.0
Tianshou (天授) ist eine RL -Bibliothek (Verstärkung Learning), die auf reinem Pytorch und Gymnasium basiert. Die Hauptmerkmale von Tianshou auf einen Blick sind:
Im Gegensatz zu anderen Verstärkungslernbibliotheken, die möglicherweise komplexe Codebasen, unfreundliche APIs auf hoher Ebene haben oder nicht für Geschwindigkeit optimiert sind, bietet Tianshou eine Hochleistungs-, modularisierte Gerüst und benutzerfreundliche Schnittstellen für den Aufbau von Tiefenlernagenten. Ein weiterer Aspekt, der Tianshou aus auseinander legt, ist seine Allgemeinheit: Es unterstützt Online- und Offline-RL-, Multi-Agent-RL- und modellbasierte Algorithmen.
Tianshou zielt darauf ab, prägnante Implementierungen sowohl für Forscher als auch für Praktiker zu ermöglichen, ohne die Flexibilität zu beeinträchtigen.
Unterstützte Algorithmen umfassen:
Andere bemerkenswerte Funktionen:
In Chinesisch bedeutet Tianshou göttlich ordiniert und abgeleitet der Gabe, geboren zu werden. Tianshou ist eine Verstärkungslernplattform, und die Natur von RL lernt nicht von Menschen. "Tianshou" zu nehmen bedeutet also, dass es keinen Lehrer gibt, aus dem man lernen kann, sondern durch sich selbst durch ständige Interaktion mit der Umwelt zu lernen.
"天授" 意指上天所授 ， 引申为与生具有的天赋。天授是强化学习平台 ， 而强化学习算法并不是向人类学习的 ， 所以取 "天授" 意思是没有老师来教 ， 而是自己通过跟环境不断交互来进行学习。 而是自己通过跟环境不断交互来进行学习。 而是自己通过跟环境不断交互来进行学习。
Tianshou wird derzeit auf Pypi und Conda-Forge veranstaltet. Es erfordert Python> = 3.11.
Für die Installation der neuesten Version von Tianshou ist das beste Weg, das Repository zu klonen und sie mit Gedichten zu installieren (die Sie zuerst auf Ihrem System installieren müssen)
git clone [email protected]:thu-ml/tianshou.git
cd tianshou
poetry install Sie können die Entwickleranforderungen auch installieren, indem Sie --with dev oder Extras für MUJOCO und Beschleunigung durch Envpool hinzuzufügen, indem Sie --extras "mujoco envpool" hinzufügen, hinzufügen.
Wenn Sie mehrere Extras installieren möchten, stellen Sie sicher, dass Sie diese in einen einzigen Befehl einbeziehen. Sequentielle Aufrufe zur poetry install --extras xxx überschreibt frühere Installationen und bleibt nur die zuletzt angegebenen Extras installiert. Oder Sie können alle folgenden Extras durch Hinzufügen --all-extras einbauen.
Verfügbare Extras sind:
atari (für Atari -Umgebungen)box2d (für Box2d -Umgebungen)classic_control (für klassische Kontrollumgebungen (diskrete) Umgebungen)mujoco (für Mujoco -Umgebungen)mujoco-py (für Legacy Mujoco-Py-Umgebungen 1 )pybullet (für Pybullet -Umgebungen)robotics (für Gymnasium-Robotikumgebungen)vizdoom (für Vizdoom -Umgebungen)envpool (für Envpool -Integration)argparse (um die hochstufigen API -Beispiele ausführen zu können)Andernfalls können Sie die neueste Version von PYPI (derzeit weit hinter dem Master) mit dem folgenden Befehl installieren:
$ pip install tianshouWenn Sie Anaconda oder Miniconda verwenden, können Sie Tianshou von Conda-Forge installieren:
$ conda install tianshou -c conda-forgeAlternativ zur Poesie -Installation können Sie auch die neueste Quellversion über GitHub installieren:
$ pip install git+https://github.com/thu-ml/tianshou.git@master --upgradeSchließlich können Sie die Installation über Ihre Python -Konsole wie folgt überprüfen:
import tianshou
print ( tianshou . __version__ )Wenn keine Fehler gemeldet werden, haben Sie Tianshou erfolgreich installiert.
Tutorials und API -Dokumentation werden auf Tianshou.readthedocs.io gehostet.
Finden Sie Beispielskripte im Test/ und Beispiele/ Ordner.
| RL -Plattform | Dokumentation | Codeabdeckung | Geben Sie Hinweise ein | Letztes Update |
|---|---|---|---|---|
| Stabile-Baselines3 | ✔️ | |||
| Ray/Rllib | ➖ (1) | ✔️ | ||
| Spinningup | ||||
| Dopamin | ||||
| GIPFEL | ➖ (1) | ✔️ | ||
| Beispielfabrik | ➖ | |||
| Tianshou | ✔️ |
(1): Es hat eine kontinuierliche Integration, aber die Abdeckungsrate ist nicht verfügbar
Tianshou wird streng getestet. Im Gegensatz zu anderen RL -Plattformen enthalten unsere Tests das vollständige Verfahren zur Schulungsschulung für alle implementierten Algorithmen . Unsere Tests würden einmal fehlschlagen, wenn einer der Agenten bei begrenzten Epochen kein konsistentes Leistungsniveau erzielt würde. Unsere Tests gewährleisten somit die Reproduzierbarkeit. Weitere Informationen finden Sie auf der Seite GitHub Actions.
Die Ergebnisse von Atari und Mujoco finden Sie in den Beispielen/ Atari/ und Beispielen/ Mujoco/ Ordnern. Unsere Mujoco -Ergebnisse erreichen oder übertreffen den Leistungsniveau der meisten vorhandenen Benchmarks.
Alle Algorithmen implementieren die folgende, hoch allgemeine API:
__init__ : Initialisieren Sie die Richtlinie;forward : Berechnen Sie Aktionen basierend auf bestimmten Beobachtungen;process_buffer : Prozessanfangspuffer, der für einige Offline -Lernalgorithmen nützlich istprocess_fn : Vorverarbeitungsdaten aus dem Replay-Puffer (da wir alle Algorithmen zur Wiederholung von Puffer-basierten Algorithmen neu formuliert haben);learn : Lernen Sie aus einer bestimmten Datenstapel;post_process_fn : Aktualisieren Sie den Replay -Puffer aus dem Lernprozess (z. B. priorisierte Replay -Puffer muss das Gewicht aktualisieren);update : Die Hauptschnittstelle für das Training, dh process_fn -> learn -> post_process_fn .Die Implementierung dieser API genügt, dass ein neuer Algorithmus innerhalb von Tianshou anwendbar ist, was experimen mit neuen Ansätzen besonders einfach wird.
Tianshou bietet zwei API -Ebenen:
Betrachten wir im Folgenden eine Beispielanwendung mit der Cartpole -Gymnasiumumgebung. Wir werden den Lernalgorithmus für Deep Q Network (DQN) mit beiden APIs anwenden.
Um loszulegen, brauchen wir einige Importe.
from tianshou . highlevel . config import SamplingConfig
from tianshou . highlevel . env import (
EnvFactoryRegistered ,
VectorEnvType ,
)
from tianshou . highlevel . experiment import DQNExperimentBuilder , ExperimentConfig
from tianshou . highlevel . params . policy_params import DQNParams
from tianshou . highlevel . trainer import (
EpochTestCallbackDQNSetEps ,
EpochTrainCallbackDQNSetEps ,
EpochStopCallbackRewardThreshold
) In der hochrangigen API ist die Grundlage für ein RL-Experiment ein ExperimentBuilder , mit dem wir das Experiment aufbauen können, das wir dann laufen wollen. Da wir DQN verwenden möchten, verwenden wir die Spezialisierung DQNExperimentBuilder . Die anderen Importe dienen dazu, Konfigurationsoptionen für unser Experiment bereitzustellen.
Die hochrangige API bietet eine weitgehend deklarative Semantik, dh der Code befasst sich fast ausschließlich mit der Konfiguration, die steuert, was zu tun ist (und nicht, wie es zu tun).
experiment = (
DQNExperimentBuilder (
EnvFactoryRegistered ( task = "CartPole-v1" , train_seed = 0 , test_seed = 0 , venv_type = VectorEnvType . DUMMY ),
ExperimentConfig (
persistence_enabled = False ,
watch = True ,
watch_render = 1 / 35 ,
watch_num_episodes = 100 ,
),
SamplingConfig (
num_epochs = 10 ,
step_per_epoch = 10000 ,
batch_size = 64 ,
num_train_envs = 10 ,
num_test_envs = 100 ,
buffer_size = 20000 ,
step_per_collect = 10 ,
update_per_step = 1 / 10 ,
),
)
. with_dqn_params (
DQNParams (
lr = 1e-3 ,
discount_factor = 0.9 ,
estimation_step = 3 ,
target_update_freq = 320 ,
),
)
. with_model_factory_default ( hidden_sizes = ( 64 , 64 ))
. with_epoch_train_callback ( EpochTrainCallbackDQNSetEps ( 0.3 ))
. with_epoch_test_callback ( EpochTestCallbackDQNSetEps ( 0.0 ))
. with_epoch_stop_callback ( EpochStopCallbackRewardThreshold ( 195 ))
. build ()
)
experiment . run ()Der Experimentbauer nimmt drei Argumente vor:
watch=True ) ( watch_num_episodes=100 ). Wir haben behinderte Beharrlichkeit, da wir keine Trainingsprotokolle, den Agenten oder seine Konfiguration für die zukünftige Verwendung speichern möchten.num_epochs=10 )step_per_epoch=10000 ). Jede Epoche besteht aus einer Reihe von Rollout -Schritten und Trainingsschritten (Datenerfassung). Der Parameter step_per_collect steuert die Datenmenge, die in jedem Sammelschritt erfasst wird. Nach jedem Sammelschritt führen wir einen Trainingsschritt durch und wenden ein durch den Datenpuffer entnommener Datenpuffer auf der Grundlage einer Datenprobe ( batch_size=64 ) angewendet werden. Weitere Einzelheiten finden Sie in der Dokumentation von SamplingConfig .Anschließend konfigurieren wir einige der Parameter des DQN -Algorithmus selbst und des neuronalen Netzwerkmodells, das wir verwenden möchten. Ein DQN-spezifisches Detail ist die Verwendung von Rückrufen zur Konfiguration des Epsilon-Parameters des Algorithmus zur Erkundung. Wir möchten zufällige Erkundungen während der Rollouts (Zug -Rückruf) verwenden, aber wenn wir die Leistung des Agenten in den Testumgebungen bewerten (Test -Rückruf).
Suchen Sie das Skript in Beispielen/diskrete/diskrete_dqn_hl.py. Hier ist ein Lauf (mit der Trainingszeit verkürzt):
Finden Sie viele weitere Anwendungen der hochrangigen API in den examples/ Ordner; Suchen Sie nach Skripten, die mit _hl.py enden. Beachten Sie, dass die meisten dieser Beispiele das zusätzliche Paket argparse erfordern (installieren Sie es durch Hinzufügen --extras argparse beim Aufrufen von Poesie).
Betrachten wir nun ein analoges Beispiel in der prozeduralen API. Suchen Sie das vollständige Skript in Beispielen/Discrete/diskrete_dqn.py.
Importieren Sie zunächst einige relevante Pakete:
import gymnasium as gym
import torch
from torch . utils . tensorboard import SummaryWriter
import tianshou as tsDefinieren Sie einige Hyperparameter:
task = 'CartPole-v1'
lr , epoch , batch_size = 1e-3 , 10 , 64
train_num , test_num = 10 , 100
gamma , n_step , target_freq = 0.9 , 3 , 320
buffer_size = 20000
eps_train , eps_test = 0.1 , 0.05
step_per_epoch , step_per_collect = 10000 , 10Initialisieren Sie den Logger:
logger = ts . utils . TensorboardLogger ( SummaryWriter ( 'log/dqn' ))
# For other loggers, see https://tianshou.readthedocs.io/en/master/01_tutorials/05_logger.htmlUmgebungen machen:
# You can also try SubprocVectorEnv, which will use parallelization
train_envs = ts . env . DummyVectorEnv ([ lambda : gym . make ( task ) for _ in range ( train_num )])
test_envs = ts . env . DummyVectorEnv ([ lambda : gym . make ( task ) for _ in range ( test_num )])Erstellen Sie das Netzwerk sowie den Optimierer:
from tianshou . utils . net . common import Net
# Note: You can easily define other networks.
# See https://tianshou.readthedocs.io/en/master/01_tutorials/00_dqn.html#build-the-network
env = gym . make ( task , render_mode = "human" )
state_shape = env . observation_space . shape or env . observation_space . n
action_shape = env . action_space . shape or env . action_space . n
net = Net ( state_shape = state_shape , action_shape = action_shape , hidden_sizes = [ 128 , 128 , 128 ])
optim = torch . optim . Adam ( net . parameters (), lr = lr )Richten Sie die Richtlinien und Sammler ein:
policy = ts . policy . DQNPolicy (
model = net ,
optim = optim ,
discount_factor = gamma ,
action_space = env . action_space ,
estimation_step = n_step ,
target_update_freq = target_freq
)
train_collector = ts . data . Collector ( policy , train_envs , ts . data . VectorReplayBuffer ( buffer_size , train_num ), exploration_noise = True )
test_collector = ts . data . Collector ( policy , test_envs , exploration_noise = True ) # because DQN uses epsilon-greedy methodLass es uns trainieren:
result = ts . trainer . OffpolicyTrainer (
policy = policy ,
train_collector = train_collector ,
test_collector = test_collector ,
max_epoch = epoch ,
step_per_epoch = step_per_epoch ,
step_per_collect = step_per_collect ,
episode_per_test = test_num ,
batch_size = batch_size ,
update_per_step = 1 / step_per_collect ,
train_fn = lambda epoch , env_step : policy . set_eps ( eps_train ),
test_fn = lambda epoch , env_step : policy . set_eps ( eps_test ),
stop_fn = lambda mean_rewards : mean_rewards >= env . spec . reward_threshold ,
logger = logger ,
). run ()
print ( f"Finished training in { result . timing . total_time } seconds" ) Speichern/laden Sie die geschulte Richtlinie (es ist genau das gleiche wie das Laden einer torch.nn.module ):
torch . save ( policy . state_dict (), 'dqn.pth' )
policy . load_state_dict ( torch . load ( 'dqn.pth' ))Beobachten Sie den Agenten mit 35 fps:
policy . eval ()
policy . set_eps ( eps_test )
collector = ts . data . Collector ( policy , env , exploration_noise = True )
collector . collect ( n_episode = 1 , render = 1 / 35 )Überprüfen Sie die in Tensorboard gespeicherten Daten:
$ tensorboard --logdir log/dqnBitte lesen Sie die Dokumentation für die erweiterte Verwendung.
Tianshou ist noch in der Entwicklung. Weitere Algorithmen und Funktionen werden kontinuierlich hinzugefügt, und wir begrüßen immer Beiträge, um Tianshou zu verbessern. Wenn Sie einen Beitrag leisten möchten, lesen Sie bitte diesen Link.
Wenn Sie Tianshou nützlich finden, zitieren Sie es bitte in Ihren Veröffentlichungen.
@article{tianshou,
author = {Jiayi Weng and Huayu Chen and Dong Yan and Kaichao You and Alexis Duburcq and Minghao Zhang and Yi Su and Hang Su and Jun Zhu},
title = {Tianshou: A Highly Modularized Deep Reinforcement Learning Library},
journal = {Journal of Machine Learning Research},
year = {2022},
volume = {23},
number = {267},
pages = {1--6},
url = {http://jmlr.org/papers/v23/21-1127.html}
}Tianshou wird vom Appliedai Institute for Europe unterstützt, der sich für eine langfristige Unterstützung und Entwicklung einsetzt.
Tianshou war zuvor eine Verstärkungslernplattform, die auf Tensorflow basierte. Sie können die Branch priv für weitere Details überprüfen. Vielen Dank an Haoshg Zous Pionierarbeit für Tianshou vor Version 0.1.1.
Wir möchten uns Tsail und Institute für künstliche Intelligenz und Universität Tsinghua für die Bereitstellung einer so ausgezeichneten KI -Forschungsplattform bedanken.
mujoco-py ist ein Legacy-Paket und wird für neue Projekte nicht empfohlen. Es ist nur für die Kompatibilität mit älteren Projekten enthalten. Beachten Sie auch, dass möglicherweise Kompatibilitätsprobleme mit MacOS neuer als Monterey kommen. ↩
