Skip to content

Latest commit

 

History

History
167 lines (117 loc) · 7.11 KB

getting-started.rst

File metadata and controls

167 lines (117 loc) · 7.11 KB
Raw

Getting Started with Ray Tune

This tutorial will walk you through the process of setting up a Tune experiment. To get started, we take a PyTorch model and show you how to leverage Ray Tune to optimize the hyperparameters of this model. Specifically, we'll leverage early stopping and Bayesian Optimization via HyperOpt to do so.

Tip

If you have suggestions on how to improve this tutorial, please let us know!

To run this example, you will need to install the following:

$ pip install "ray[tune]" torch torchvision

Setting Up a Pytorch Model to Tune

To start off, let's first import some dependencies. We import some PyTorch and TorchVision modules to help us create a model and train it. Also, we'll import Ray Tune to help us optimize the model. As you can see we use a so-called scheduler, in this case the ASHAScheduler that we will use for tuning the model later in this tutorial.

/../../python/ray/tune/tests/tutorial.py

Then, let's define a simple PyTorch model that we'll be training. If you're not familiar with PyTorch, the simplest way to define a model is to implement a nn.Module. This requires you to set up your model with __init__ and then implement a forward pass. In this example we're using a small convolutional neural network consisting of one 2D convolutional layer, a fully connected layer, and a softmax function.

/../../python/ray/tune/tests/tutorial.py

Below, we have implemented functions for training and evaluating your Pytorch model. We define a train and a test function for that purpose. If you know how to do this, skip ahead to the next section.

Training and evaluating the model

/../../python/ray/tune/tests/tutorial.py

Setting up a Tuner for a Training Run with Tune

Below, we define a function that trains the Pytorch model for multiple epochs. This function will be executed on a separate Ray Actor (process) <actor-guide> underneath the hood, so we need to communicate the performance of the model back to Tune (which is on the main Python process).

To do this, we call train.report() <ray.train.report> in our training function, which sends the performance value back to Tune. Since the function is executed on the separate process, make sure that the function is serializable by Ray <serialization-guide>.

/../../python/ray/tune/tests/tutorial.py

Let's run one trial by calling Tuner.fit <tune-run-ref> and randomly sample <tune-search-space> from a uniform distribution for learning rate and momentum.

/../../python/ray/tune/tests/tutorial.py

Tuner.fit returns an ResultGrid object <tune-analysis-docs>. You can use this to plot the performance of this trial.

/../../python/ray/tune/tests/tutorial.py

Note

Tune will automatically run parallel trials across all available cores/GPUs on your machine or cluster. To limit the number of concurrent trials, use the ConcurrencyLimiter <limiter>.

Early Stopping with Adaptive Successive Halving (ASHAScheduler)

Let's integrate early stopping into our optimization process. Let's use ASHA <tune-scheduler-hyperband>, a scalable algorithm for principled early stopping.

On a high level, ASHA terminates trials that are less promising and allocates more time and resources to more promising trials. As our optimization process becomes more efficient, we can afford to increase the search space by 5x, by adjusting the parameter num_samples.

ASHA is implemented in Tune as a "Trial Scheduler". These Trial Schedulers can early terminate bad trials, pause trials, clone trials, and alter hyperparameters of a running trial. See the TrialScheduler documentation <tune-schedulers> for more details of available schedulers and library integrations.

/../../python/ray/tune/tests/tutorial.py

You can run the below in a Jupyter notebook to visualize trial progress.

/../../python/ray/tune/tests/tutorial.py

image

You can also use TensorBoard <tensorboard> for visualizing results.

$ tensorboard --logdir {logdir}

Using Search Algorithms in Tune

In addition to TrialSchedulers <tune-schedulers>, you can further optimize your hyperparameters by using an intelligent search technique like Bayesian Optimization. To do this, you can use a Tune Search Algorithm <tune-search-alg>. Search Algorithms leverage optimization algorithms to intelligently navigate the given hyperparameter space.

Note that each library has a specific way of defining the search space.

/../../python/ray/tune/tests/tutorial.py

Note

Tune allows you to use some search algorithms in combination with different trial schedulers. See this page for more details <tune-schedulers>.

Evaluating Your Model after Tuning

You can evaluate best trained model using the ExperimentAnalysis object <tune-analysis-docs> to retrieve the best model:

/../../python/ray/tune/tests/tutorial.py

Next Steps

  • Check out the Tune tutorials <tune-guides> for guides on using Tune with your preferred machine learning library.
  • Browse our gallery of examples <examples/other-examples> to see how to use Tune with PyTorch, XGBoost, Tensorflow, etc.
  • Let us know if you ran into issues or have any questions by opening an issue on our Github.
  • To check how your application is doing, you can use the Ray dashboard <observability-getting-started>.