Skip to main content

A Library for Deep Reinforcement Learning

Project description

PyPI Conda Read the Docs Read the Docs Unittest codecov GitHub issues GitHub stars GitHub forks GitHub license

⚠️️ Transition to Gymnasium: The maintainers of OpenAI Gym have recently released Gymnasium, which is where future maintenance of OpenAI Gym will be taking place. Tianshou has transitioned to internally using Gymnasium environments. You can still use OpenAI Gym environments with Tianshou vector environments, but they will be wrapped in a compatibility layer, which could be a source of issues. We recommend that you update your environment code to Gymnasium. If you want to continue using OpenAI Gym with Tianshou, you need to manually install Gym and Shimmy (the compatibility layer).

Tianshou (天授) is a reinforcement learning platform based on pure PyTorch. Unlike existing reinforcement learning libraries, which are mainly based on TensorFlow, have many nested classes, unfriendly API, or slow-speed, Tianshou provides a fast-speed modularized framework and pythonic API for building the deep reinforcement learning agent with the least number of lines of code. The supported interface algorithms currently include:

Here are Tianshou's other features:

  • Elegant framework, using only ~4000 lines of code
  • State-of-the-art MuJoCo benchmark for REINFORCE/A2C/TRPO/PPO/DDPG/TD3/SAC algorithms
  • Support vectorized environment (synchronous or asynchronous) for all algorithms Usage
  • Support super-fast vectorized environment EnvPool for all algorithms Usage
  • Support recurrent state representation in actor network and critic network (RNN-style training for POMDP) Usage
  • Support any type of environment state/action (e.g. a dict, a self-defined class, ...) Usage
  • Support customized training process Usage
  • Support n-step returns estimation and prioritized experience replay for all Q-learning based algorithms; GAE, nstep and PER are very fast thanks to numba jit function and vectorized numpy operation
  • Support multi-agent RL Usage
  • Support both TensorBoard and W&B log tools
  • Support multi-GPU training Usage
  • Comprehensive documentation, PEP8 code-style checking, type checking and thorough tests

In Chinese, Tianshou means divinely ordained and is derived to the gift of being born with. Tianshou is a reinforcement learning platform, and the RL algorithm does not learn from humans. So taking "Tianshou" means that there is no teacher to study with, but rather to learn by themselves through constant interaction with the environment.



Tianshou is currently hosted on PyPI and conda-forge. It requires Python >= 3.6.

You can simply install Tianshou from PyPI with the following command:

$ pip install tianshou

If you use Anaconda or Miniconda, you can install Tianshou from conda-forge through the following command:

$ conda install -c conda-forge tianshou

You can also install with the newest version through GitHub:

$ pip install git+ --upgrade

After installation, open your python console and type

import tianshou

If no error occurs, you have successfully installed Tianshou.


The tutorials and API documentation are hosted on

The example scripts are under test/ folder and examples/ folder.


Why Tianshou?

Comprehensive Functionality

RL Platform GitHub Stars # of Alg. (1) Custom Env Batch Training RNN Support Nested Observation Backend
Baselines GitHub stars 9 :heavy_check_mark: (gym) :heavy_minus_sign: (2) :heavy_check_mark: :x: TF1
Stable-Baselines GitHub stars 11 :heavy_check_mark: (gym) :heavy_minus_sign: (2) :heavy_check_mark: :x: TF1
Stable-Baselines3 GitHub stars 7 (3) :heavy_check_mark: (gym) :heavy_minus_sign: (2) :x: :heavy_check_mark: PyTorch
Ray/RLlib GitHub stars 16 :heavy_check_mark: :heavy_check_mark: :heavy_check_mark: :heavy_check_mark: TF/PyTorch
SpinningUp GitHub stars 6 :heavy_check_mark: (gym) :heavy_minus_sign: (2) :x: :x: PyTorch
Dopamine GitHub stars 7 :x: :x: :x: :x: TF/JAX
ACME GitHub stars 14 :heavy_check_mark: (dm_env) :heavy_check_mark: :heavy_check_mark: :heavy_check_mark: TF/JAX
keras-rl GitHub stars 7 :heavy_check_mark: (gym) :x: :x: :x: Keras
rlpyt GitHub stars 11 :x: :heavy_check_mark: :heavy_check_mark: :heavy_check_mark: PyTorch
ChainerRL GitHub stars 18 :heavy_check_mark: (gym) :heavy_check_mark: :heavy_check_mark: :x: Chainer
Sample Factory GitHub stars 1 (4) :heavy_check_mark: (gym) :heavy_check_mark: :heavy_check_mark: :heavy_check_mark: PyTorch
Tianshou GitHub stars 20 :heavy_check_mark: (Gymnasium) :heavy_check_mark: :heavy_check_mark: :heavy_check_mark: PyTorch

(1): access date: 2021-08-08

(2): not all algorithms support this feature

(3): TQC and QR-DQN in sb3-contrib instead of main repo

(4): super fast APPO!

High quality software engineering standard

RL Platform Documentation Code Coverage Type Hints Last Update
Baselines :x: :x: :x: GitHub last commit
Stable-Baselines Documentation Status coverage :x: GitHub last commit
Stable-Baselines3 Documentation Status coverage report :heavy_check_mark: GitHub last commit
Ray/RLlib :heavy_minus_sign:(1) :heavy_check_mark: GitHub last commit
SpinningUp :x: :x: GitHub last commit
Dopamine :x: :x: GitHub last commit
ACME :heavy_minus_sign:(1) :heavy_check_mark: GitHub last commit
keras-rl Documentation :heavy_minus_sign:(1) :x: GitHub last commit
rlpyt Docs codecov :x: GitHub last commit
ChainerRL Documentation Status Coverage Status :x: GitHub last commit
Sample Factory :heavy_minus_sign: codecov :x: GitHub last commit
Tianshou Read the Docs codecov :heavy_check_mark: GitHub last commit

(1): it has continuous integration but the coverage rate is not available

Reproducible and High Quality Result

Tianshou has its tests. Different from other platforms, the tests include the full agent training procedure for all of the implemented algorithms. It would be failed once if it could not train an agent to perform well enough on limited epochs on toy scenarios. The tests secure the reproducibility of our platform. Check out the GitHub Actions page for more detail.

The Atari/Mujoco benchmark results are under examples/atari/ and examples/mujoco/ folders. Our Mujoco result can beat most of existing benchmark.

Modularized Policy

We decouple all of the algorithms roughly into the following parts:

  • __init__: initialize the policy;
  • forward: to compute actions over given observations;
  • process_fn: to preprocess data from replay buffer (since we have reformulated all algorithms to replay-buffer based algorithms);
  • learn: to learn from a given batch data;
  • post_process_fn: to update the replay buffer from the learning process (e.g., prioritized replay buffer needs to update the weight);
  • update: the main interface for training, i.e., process_fn -> learn -> post_process_fn.

Within this API, we can interact with different policies conveniently.

Quick Start

This is an example of Deep Q Network. You can also run the full script at test/discrete/

First, import some relevant packages:

import gymnasium as gym
import torch, numpy as np, torch.nn as nn
from torch.utils.tensorboard import SummaryWriter
import tianshou as ts

Define some hyper-parameters:

task = 'CartPole-v0'
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, 10
logger = ts.utils.TensorboardLogger(SummaryWriter('log/dqn'))  # TensorBoard is supported!
# For other loggers:

Make environments:

# you can also try with SubprocVectorEnv
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)])

Define the network:

from import Net
# you can define other net by following the API:
env = gym.make(task)
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)

Setup policy and collectors:

policy = ts.policy.DQNPolicy(net, optim, gamma, n_step, target_update_freq=target_freq)
train_collector =, train_envs,, train_num), exploration_noise=True)
test_collector =, test_envs, exploration_noise=True)  # because DQN uses epsilon-greedy method

Let's train it:

result = ts.trainer.offpolicy_trainer(
    policy, train_collector, test_collector, epoch, step_per_epoch, step_per_collect,
    test_num, 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,
print(f'Finished training! Use {result["duration"]}')

Save / load the trained policy (it's exactly the same as PyTorch nn.module):, 'dqn.pth')

Watch the performance with 35 FPS:

collector =, env, exploration_noise=True)
collector.collect(n_episode=1, render=1 / 35)

Look at the result saved in tensorboard: (with bash script in your terminal)

$ tensorboard --logdir log/dqn

You can check out the documentation for advanced usage.

It's worth a try: here is a test on a laptop (i7-8750H + GTX1060). It only uses 3 seconds for training an agent based on vanilla policy gradient on the CartPole-v0 task: (seed may be different across different platform and device)

$ python3 test/discrete/ --seed 0 --render 0.03


Tianshou is still under development. More algorithms and features are going to be added and we always welcome contributions to help make Tianshou better. If you would like to contribute, please check out this link.

Citing Tianshou

If you find Tianshou useful, please cite it in your publications.

  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     = {}


Tianshou was previously a reinforcement learning platform based on TensorFlow. You can check out the branch priv for more detail. Many thanks to Haosheng Zou's pioneering work for Tianshou before version 0.1.1.

We would like to thank TSAIL and Institute for Artificial Intelligence, Tsinghua University for providing such an excellent AI research platform.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

tianshou-0.5.0.tar.gz (123.9 kB view hashes)

Uploaded source

Built Distribution

tianshou-0.5.0-py3-none-any.whl (162.7 kB view hashes)

Uploaded py3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page