All Projects → JuliaReinforcementLearning → ReinforcementLearningZoo.jl

JuliaReinforcementLearning / ReinforcementLearningZoo.jl

Licence: MIT License
juliareinforcementlearning.org/

Programming Languages

julia
2034 projects

Projects that are alternatives of or similar to ReinforcementLearningZoo.jl

Deep-Reinforcement-Learning-With-Python
Master classic RL, deep RL, distributional RL, inverse RL, and more using OpenAI Gym and TensorFlow with extensive Math
Stars: ✭ 222 (+382.61%)
Mutual labels:  dqn, ddpg, sac, c51, ppo, a2c, td3
Rainy
☔ Deep RL agents with PyTorch☔
Stars: ✭ 39 (-15.22%)
Mutual labels:  dqn, ddpg, sac, ppo, a2c, td3
Deep RL with pytorch
A pytorch tutorial for DRL(Deep Reinforcement Learning)
Stars: ✭ 160 (+247.83%)
Mutual labels:  dqn, c51, iqn, ppo, a2c, counterfactual-regret-minimization
ElegantRL
Scalable and Elastic Deep Reinforcement Learning Using PyTorch. Please star. 🔥
Stars: ✭ 2,074 (+4408.7%)
Mutual labels:  dqn, ddpg, sac, ppo, a2c, td3
Deeprl
Modularized Implementation of Deep RL Algorithms in PyTorch
Stars: ✭ 2,640 (+5639.13%)
Mutual labels:  rainbow, dqn, ddpg, ppo, a2c, td3
Tianshou
An elegant PyTorch deep reinforcement learning library.
Stars: ✭ 4,109 (+8832.61%)
Mutual labels:  dqn, ddpg, sac, ppo, a2c, td3
Minimalrl
Implementations of basic RL algorithms with minimal lines of codes! (pytorch based)
Stars: ✭ 2,051 (+4358.7%)
Mutual labels:  dqn, ddpg, sac, ppo, a2c
Paddle-RLBooks
Paddle-RLBooks is a reinforcement learning code study guide based on pure PaddlePaddle.
Stars: ✭ 113 (+145.65%)
Mutual labels:  dqn, ddpg, sac, c51, td3
model-free-algorithms
TD3, SAC, IQN, Rainbow, PPO, Ape-X and etc. in TF1.x
Stars: ✭ 56 (+21.74%)
Mutual labels:  rainbow, ddpg, sac, ppo, td3
Deep-rl-mxnet
Mxnet implementation of Deep Reinforcement Learning papers, such as DQN, PG, DDPG, PPO
Stars: ✭ 26 (-43.48%)
Mutual labels:  dqn, ddpg, a2c, td3
TF2-RL
Reinforcement learning algorithms implemented for Tensorflow 2.0+ [DQN, DDPG, AE-DDPG, SAC, PPO, Primal-Dual DDPG]
Stars: ✭ 160 (+247.83%)
Mutual labels:  dqn, ddpg, sac, ppo
Deep-Reinforcement-Learning-Notebooks
This Repository contains a series of google colab notebooks which I created to help people dive into deep reinforcement learning.This notebooks contain both theory and implementation of different algorithms.
Stars: ✭ 15 (-67.39%)
Mutual labels:  rainbow, dqn, ppo, a2c
LWDRLC
Lightweight deep RL Libraray for continuous control.
Stars: ✭ 14 (-69.57%)
Mutual labels:  ddpg, sac, ppo, td3
Easy Rl
强化学习中文教程,在线阅读地址:https://datawhalechina.github.io/easy-rl/
Stars: ✭ 3,004 (+6430.43%)
Mutual labels:  dqn, ddpg, ppo
Torchrl
Pytorch Implementation of Reinforcement Learning Algorithms ( Soft Actor Critic(SAC)/ DDPG / TD3 /DQN / A2C/ PPO / TRPO)
Stars: ✭ 90 (+95.65%)
Mutual labels:  dqn, ddpg, ppo
Machin
Reinforcement learning library(framework) designed for PyTorch, implements DQN, DDPG, A2C, PPO, SAC, MADDPG, A3C, APEX, IMPALA ...
Stars: ✭ 145 (+215.22%)
Mutual labels:  dqn, ddpg, ppo
Reinforcement Learning With Tensorflow
Simple Reinforcement learning tutorials, 莫烦Python 中文AI教学
Stars: ✭ 6,948 (+15004.35%)
Mutual labels:  dqn, ddpg, ppo
Deep Reinforcement Learning Algorithms
31 projects in the framework of Deep Reinforcement Learning algorithms: Q-learning, DQN, PPO, DDPG, TD3, SAC, A2C and others. Each project is provided with a detailed training log.
Stars: ✭ 167 (+263.04%)
Mutual labels:  dqn, ddpg, ppo
Machine Learning Is All You Need
🔥🌟《Machine Learning 格物志》: ML + DL + RL basic codes and notes by sklearn, PyTorch, TensorFlow, Keras & the most important, from scratch!💪 This repository is ALL You Need!
Stars: ✭ 173 (+276.09%)
Mutual labels:  dqn, ddpg, ppo
Autonomous Learning Library
A PyTorch library for building deep reinforcement learning agents.
Stars: ✭ 425 (+823.91%)
Mutual labels:  dqn, ddpg, ppo

⚠️ This package is moved into ReinforcementLearning.jl (2021-05-06)

This project aims to provide some implementations of the most typical reinforcement learning algorithms.

Algorithms Implemented

  • VPG (Vanilla Policy Gradient, with a baseline)
  • DQN
  • Prioritized DQN
  • Rainbow
  • IQN
  • A2C/A2C with GAE/MAC
  • PPO
  • DDPG
  • TD3
  • SAC
  • CFR/OS-MCCFR/ES-MCCFR/DeepCFR
  • Minimax
  • Behavior Cloning

If you are looking for tabular reinforcement learning algorithms, you may refer ReinforcementLearningAnIntroduction.jl.

Built-in Experiments

Some built-in experiments are exported to help new users to easily run benchmarks with one line. For experienced users, you are suggested to check the source code of those experiments and make changes as needed.

List of built-in experiments

  • E`JuliaRL_BasicDQN_CartPole`
  • E`JuliaRL_DQN_CartPole`
  • E`JuliaRL_PrioritizedDQN_CartPole`
  • E`JuliaRL_Rainbow_CartPole`
  • E`JuliaRL_IQN_CartPole`
  • E`JuliaRL_A2C_CartPole`
  • E`JuliaRL_A2CGAE_CartPole` (Thanks to @sriram13m)
  • E`JuliaRL_MAC_CartPole` (Thanks to @RajGhugare19)
  • E`JuliaRL_PPO_CartPole`
  • E`JuliaRL_VPG_CartPole` (Thanks to @norci)
  • E`JuliaRL_VPG_Pendulum` (continuous action space)
  • E`JuliaRL_VPG_PendulumD` (discrete action space)
  • E`JuliaRL_DDPG_Pendulum`
  • E`JuliaRL_TD3_Pendulum` (Thanks to @rbange)
  • E`JuliaRL_SAC_Pendulum` (Thanks to @rbange)
  • E`JuliaRL_PPO_Pendulum`
  • E`JuliaRL_BasicDQN_MountainCar` (Thanks to @felixchalumeau)
  • E`JuliaRL_DQN_MountainCar` (Thanks to @felixchalumeau)
  • E`JuliaRL_Minimax_OpenSpiel(tic_tac_toe)`
  • E`JuliaRL_TabularCFR_OpenSpiel(kuhn_poker)`
  • E`JuliaRL_DeepCFR_OpenSpiel(leduc_poker)`
  • E`JuliaRL_DQN_SnakeGame`
  • E`JuliaRL_BC_CartPole`
  • E`JuliaRL_BasicDQN_EmptyRoom`
  • E`Dopamine_DQN_Atari(pong)`
  • E`Dopamine_Rainbow_Atari(pong)`
  • E`Dopamine_IQN_Atari(pong)`
  • E`rlpyt_A2C_Atari(pong)`
  • E`rlpyt_PPO_Atari(pong)`

Run Experiments

julia> ] add ReinforcementLearning

julia> using ReinforcementLearning

julia> run(E`JuliaRL_BasicDQN_CartPole`)

julia> ] add ArcadeLearningEnvironment

julia> using ArcadeLearningEnvironment

julia> run(E`rlpyt_PPO_Atari(pong)`)  # the Atari environment is provided in ArcadeLearningEnvironment, so we need to install it first

Notes:

  • Experiments on CartPole usually run faster with CPU only due to the overhead of sending data between CPU and GPU.
  • It shouldn't surprise you that our experiments on CartPole are much faster than those written in Python. The secret is that our environment is written in Julia!
  • Remember to set JULIA_NUM_THREADS to enable multi-threading when using algorithms like A2C and PPO.
  • Experiments on Atari (OpenSpiel, SnakeGame, GridWorlds) are only available after you have ArcadeLearningEnvironment.jl (OpenSpiel.jl, SnakeGame.jl, GridWorlds.jl) installed and using ArcadeLearningEnvironment (using OpenSpiel, using SnakeGame, import GridWorlds).

Speed

  • Different configurations might affect the performance a lot. According to our tests, our implementations are generally comparable to those written in PyTorch or TensorFlow with the same configuration (sometimes we are significantly faster).

The following data are collected from experiments on Intel(R) Xeon(R) W-2123 CPU @ 3.60GHz with a GPU card of RTX 2080ti.

Experiment FPS Notes
E`Dopamine_DQN_Atari(pong)` ~210 Use the same config of dqn.gin in google/dopamine
E`Dopamine_Rainbow_Atari(pong)` ~171 Use the same config of rainbow.gin in google/dopamine
E`Dopamine_IQN_Atari(pong)` ~162 Use the same config of implicit_quantile.gin in google/dopamine
E`rlpyt_A2C_Atari(pong)` ~768 Use the same default parameters of A2C in rlpyt with 4 threads
E`rlpyt_PPO_Atari(pong)` ~711 Use the same default parameters of PPO in rlpyt with 4 threads
Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].