Skip to content
PARL A high-performance distributed training framework for Reinforcement Learning
Python Other
  1. Python 96.5%
  2. Other 3.5%
Branch: develop
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.github add some introduction for our parallelization feature (#61) Apr 13, 2019
.teamcity add sac (#188) Dec 30, 2019
benchmark/torch add torch td3 (#176) Nov 27, 2019
docs
examples add offline q learning (#193) Jan 14, 2020
papers Create ICLR_2020.md (#199) Jan 15, 2020
parl add sac (#188) Dec 30, 2019
.copyright.hook add api set_params/get_params in Model (#56) Mar 26, 2019
.gitignore implement of IMPALA with the newest parallel design (#60) Apr 8, 2019
.pre-commit-config.yaml redesign basic class in PARL (#26) Nov 20, 2018
.readthedocs.yml Onlinedocs (#84) Jul 4, 2019
.travis.yml run unittest in python2 and python3 (#55) Mar 5, 2019
CMakeLists.txt torch test env (#156) Oct 8, 2019
LICENSE Initial commit Apr 25, 2018
MANIFEST.in fix unittest bugs (#136) Aug 22, 2019
README.cn.md add sac (#188) Dec 30, 2019
README.md add sac (#188) Dec 30, 2019
setup.py Add `files` argument when creating a client. (#143) Sep 1, 2019

README.md

PARL

English | 简体中文
Documentation

PARL is a flexible and high-efficient reinforcement learning framework.

Features

Reproducible. We provide algorithms that stably reproduce the result of many influential reinforcement learning algorithms.

Large Scale. Ability to support high-performance parallelization of training with thousands of CPUs and multi-GPUs.

Reusable. Algorithms provided in the repository could be directly adapted to a new task by defining a forward network and training mechanism will be built automatically.

Extensible. Build new algorithms quickly by inheriting the abstract class in the framework.

Abstractions

abstractions

PARL aims to build an agent for training algorithms to perform complex tasks. The main abstractions introduced by PARL that are used to build an agent recursively are the following:

Model

Model is abstracted to construct the forward network which defines a policy network or critic network given state as input.

Algorithm

Algorithm describes the mechanism to update parameters in Model and often contains at least one model.

Agent

Agent, a data bridge between the environment and the algorithm, is responsible for data I/O with the outside environment and describes data preprocessing before feeding data into the training process.

Note: For more information about base classes, please visit our tutorial and API documentation.

Parallelization

PARL provides a compact API for distributed training, allowing users to transfer the code into a parallelized version by simply adding a decorator. For more information about our APIs for parallel training, please visit our documentation.
Here is a Hello World example to demonstrate how easy it is to leverage outer computation resources.

#============Agent.py=================
@parl.remote_class
class Agent(object):

    def say_hello(self):
        print("Hello World!")

    def sum(self, a, b):
        return a+b

parl.connect('localhost:8037')
agent = Agent()
agent.say_hello()
ans = agent.sum(1,5) # run remotely and not consume any local computation resources

Two steps to use outer computation resources:

  1. use the parl.remote_class to decorate a class at first, after which it is transferred to be a new class that can run in other CPUs or machines.
  2. call parl.connect to initialize parallel communication before creating an object. Calling any function of the objects does not consume local computation resources since they are executed elsewhere.

PARL

As shown in the above figure, real actors(orange circle) are running at the cpu cluster, while the learner(blue circle) is running at the local gpu with several remote actors(yellow circle with dotted edge).

For users, they can write code in a simple way, just like writing multi-thread code, but with actors consuming remote resources. We have also provided examples of parallized algorithms like IMPALA, A2C and GA3C. For more details in usage please refer to these examples.

Install:

Dependencies

  • Python 2.7 or 3.5+.
  • PaddlePaddle >=1.5.1 (Optional, if you only want to use APIs related to parallelization alone)
pip install parl

Examples

NeurlIPS2018 Half-Cheetah Breakout
NeurlIPS2018

You can’t perform that action at this time.