A Guided Tour of Ray Core

An introductory tutorial about leveraging Ray core features for distributed patterns.

These examples have been tested in the following environments:

• Ubuntu 18.04 LTS
• macOS 11.6, Big Sur

Using:

• Ray versions 1.7+
• Python versions: 3.6, 3.7, 3.8

See the slides.pdf file for the presentation slide deck that accompanies this tutorial.

Getting Started

To get started use git to clone this public repository:

git clone https://github.com/DerwenAI/ray_tutorial.git
cd ray_tutorial

Getting Started with a Virtual Environment

Set up a local virtual environment and activate it:

python3 -m venv venv
source venv/bin/activate

Then use pip to install the required dependencies:

python3 -m pip install -U pip
python3 -m pip install -r requirements.txt
python3 -m ipykernel install

Alternatively, if you use conda for installing Python packages:

conda create -n ray_tutorial python=3.7
conda activate ray_tutorial
python3 -m pip install -r requirements.txt
conda install ipykernel --name Python3

Note: if you run into any problems on Python 3.8 with "wheels" during a pip installation, you may need to use the conda approach instead.

For some of the visualizations in pi.ipynb you also need to install graphviz

Then launch the JupyterLab environment to run examples in this repo:

jupyter-lab

Browse to http://localhost:8888/lab to continue.

Getting started with Docker-Compose

First, install docker and docker-compose, then:

docker-compose up -d

Docker compose will start a JupyterLab service without requiring use of a security token.

Browse to http://localhost:8888/lab to continue.

To stop this container:

docker-compose stop

Syllabus

Overview

A Guided Tour of Ray Core covers an introductory, hands-on coding tour through the core features of Ray, which provide powerful yet easy-to-use design patterns for implementing distributed systems in Python. This training includes a brief talk to provide overview of concepts, then coding for remote functions, tasks, object references and resolutions, actors, and so on.

Then we'll follow with Q&A. All code is available in notebooks in the GitHub repo.

Intended Audience

• Python developers who want to learn how to parallelize their application code

Note: this material is not intended as an introduction to the higher level components in Ray, such as RLlib and Ray Tune.

Prerequisites

• Some prior experience developing code in Python
• Basic understanding of distributed systems

Key Takeaways

• What are the Ray core features and how to use them?
• In which contexts are the different approaches indicated?
• Profiling methods, to decide when to make trade-offs (compute cost, memory, I/O, etc.) ?

Course Outline

1. Introduction to Ray core features as a pattern language for distributed systems
2. Overview of the main Ray core features and their intended usage
3. Background, primary sources, and closely related resources about distributed systems
4. Code samples:
   • Remote Functions: ex_01_remo_func.ipynb
   • Remote Functions: ex_02_remo_func.ipynb
   • Remote Objects: ex_02_remo_objs.ipynb
   • Remote Methods: ex_03_remo_meth.ipynb
   • Multiprocessing Pool: ex_04_mult_pool.ipynb
   • JobLib: ex_05_job_lib.ipynb
5. Profiling: comparing trade-offs and overhead
   • Estimate Pi: pi.ipynb
6. Ray Summit, Anyscale Connect, developer forums, and other resources
7. Q&A

Other Recommended Reading

• Ray Design Patterns
• UC Berkeley EECS "Our Pattern Language"
• "Futures and Promises"
• "Ray Distributed Library Patterns"
• python-patterns
• Python Data Science
• "Profiling and Optimizing Jupyter Notebooks"
• Anyscale Academy
• Ray Tutorial

Kudos

@dmatrix, @penolove, @deanwampler, @ceteri.