Try Ray on Binder (Experimental)
Try the Ray tutorials online on Binder.
Make sure you have Python installed (we recommend using the Anaconda Python distribution). Ray works with both Python 2 and Python 3. If you are unsure which to use, then use Python 3.
If not using conda, continue to step 2.
If using conda, you can then run the following commands and skip the next 4 steps:
git clone https://github.com/ray-project/tutorial cd tutorial conda env create -f environment.yml conda activate ray-tutorial
Install Jupyter with
pip install jupyter. Verify that you can start a Jupyter notebook with the command
Install Ray by running
pip install -U ray. Verify that you can run
import ray ray.init()
in a Python interpreter.
Clone the tutorial repository with
git clone https://github.com/ray-project/tutorial.git
Install the following additional dependencies.
pip install modin pip install tensorflow pip install gym pip install scipy pip install opencv-python pip install bokeh pip install ipywidgets==6.0.0 pip install keras
Verify that you can run
import gymin a Python interpreter.
Note: If you have trouble installing these Python modules, note that almost all of the exercises can be done without them.
If you want to run the pong exercise (in rl_exercises/rl_exercise05.ipynb), you will need to do pip install utilities/pong_py.
exercises/exercise*.ipynb is a separate exercise. They can be
opened in a Jupyter notebook by running the following commands.
cd tutorial/exercises jupyter-notebook
If it asks for a password, just hit enter.
Instructions are written in each file. To do each exercise, first run all of the cells in the Jupyter notebook. Then modify the ones that need to be modified in order to prevent any exceptions from being raised. Throughout these exercises, you may find the Ray documentation helpful.
Exercise 1: Define a remote function, and execute multiple remote functions in parallel.
Exercise 2: Execute remote functions in parallel with some dependencies.
Exercise 3: Call remote functions from within remote functions.
Exercise 4: Use actors to share state between tasks. See the documentation on using actors.
Exercise 5: Pass actor handles to tasks so that multiple tasks can invoke methods on the same actor.
Exercise 6: Use
ray.wait to ignore stragglers. See the
documentation for wait.
Exercise 7: Use
ray.wait to process tasks in the order that they finish.
See the documentation for wait.
Exercise 8: Use
ray.put to avoid serializing and copying the same
object into shared memory multiple times.
Exercise 9: Specify that an actor requires some GPUs. For a complete example that does something similar, you may want to see the ResNet example.
Exercise 10: Specify that a remote function requires certain custom resources. See the documentation on custom resources.
Exercise 11: Extract neural network weights from an actor on one process, and set them in another actor. You may want to read the documentation on using Ray with TensorFlow.
Exercise 12: Pass object IDs into tasks to construct dependencies between tasks and perform a tree reduce.
More In-Depth Examples
Sharded Parameter Server: This exercise involves implementing a parameter server as a Ray actor, implementing a simple asynchronous distributed training algorithm, and sharding the parameter server to improve throughput.
Speed Up Pandas: This exercise involves using Modin to speed up your pandas workloads.
MapReduce: This exercise shows how to implement a toy version of the MapReduce system on top of Ray.
Each file in
rl_exercises/rl_exercise*.ipynb is a separate Jupyter notebook.
These exercises should be done in order. They can be opened in a Jupyter
notebook by running the following commands.
cd tutorial/rl_exercises jupyter-notebook
Exercise 1: Introduction to Markov Decision Processes.
Exercise 2: Derivative free optimization.
Exercise 3: Introduction to proximal policy optimization (PPO).
Exercise 4: Introduction to asynchronous advantage actor-critic (A3C).
Exercise 5: Train a policy to play pong using RLlib. Deploy it using actors, and play against the trained policy.
Tune is a library for distributed hyperparameter tuning.
tune_exercises/exercise_1_basics.ipynb covers basics of using Tune - creating your first training function and using Tune. This tutorial uses Keras.
tune_exercises/exercise_2_optimize.ipynb covers Search algorithms and Trial Schedulers to optimize your search process. This tutorial uses PyTorch.