File size: 9,125 Bytes
==========================================================
Using Reinforcement Learning with the SageMaker Python SDK
==========================================================

.. contents::

With Reinforcement Learning (RL) Estimators, you can train reinforcement learning models on Amazon SageMaker.

For supported RL toolkits and their versions, see https://github.com/aws/sagemaker-rl-container/#rl-images-provided-by-sagemaker

RL Training
-----------

Training RL models using ``RLEstimator`` is a two-step process:

1. Prepare a training script to run on SageMaker
2. Run this script on SageMaker via an ``RLEstimator``.

You should prepare your script in a separate source file than the notebook, terminal session, or source file you're
using to submit the script to SageMaker via an ``RLEstimator``. This will be discussed in further detail below.

Suppose that you already have a training script called ``coach-train.py``.
You can then create an ``RLEstimator`` with keyword arguments to point to this script and define how SageMaker runs it:

.. code:: python

    from sagemaker.rl import RLEstimator, RLToolkit, RLFramework

    rl_estimator = RLEstimator(entry_point='coach-train.py',
                               toolkit=RLToolkit.COACH,
                               toolkit_version='0.11.1',
                               framework=RLFramework.TENSORFLOW,
                               role='SageMakerRole',
                               instance_type='ml.p3.2xlarge',
                               instance_count=1)

After that, you simply tell the estimator to start a training job:

.. code:: python

    rl_estimator.fit()

In the following sections, we'll discuss how to prepare a training script for execution on SageMaker
and how to run that script on SageMaker using ``RLEstimator``.


Preparing the RL Training Script
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Your RL training script must be a Python 3.5 compatible source file from MXNet framework or Python 3.6 for TensorFlow.

The training script is very similar to a training script you might run outside of SageMaker, but you
can access useful properties about the training environment through various environment variables, such as

* ``SM_MODEL_DIR``: A string representing the path to the directory to write model artifacts to.
  These artifacts are uploaded to S3 for model hosting.
* ``SM_NUM_GPUS``: An integer representing the number of GPUs available to the host.
* ``SM_OUTPUT_DATA_DIR``: A string representing the filesystem path to write output artifacts to. Output artifacts may
  include checkpoints, graphs, and other files to save, not including model artifacts. These artifacts are compressed
  and uploaded to S3 to the same S3 prefix as the model artifacts.

For the exhaustive list of available environment variables, see the
`SageMaker Containers documentation <https://github.com/aws/sagemaker-containers#list-of-provided-environment-variables-by-sagemaker-containers>`__.


RL Estimators
-------------

The ``RLEstimator`` constructor takes both required and optional arguments.

Required arguments
~~~~~~~~~~~~~~~~~~

The following are required arguments to the ``RLEstimator`` constructor. When you create an instance of ``RLEstimator``, you must include
these in the constructor, either positionally or as keyword arguments.

-  ``entry_point`` Path (absolute or relative) to the Python file which
   should be executed as the entry point to training.
-  ``role`` An AWS IAM role (either name or full ARN). The Amazon
   SageMaker training jobs and APIs that create Amazon SageMaker
   endpoints use this role to access training data and model artifacts.
   After the endpoint is created, the inference code might use the IAM
   role, if accessing AWS resource.
-  ``instance_count`` Number of Amazon EC2 instances to use for
   training.
-  ``instance_type`` Type of EC2 instance to use for training, for
   example, 'ml.m4.xlarge'.

You must as well include either:

-  ``toolkit`` RL toolkit (Ray RLlib or Coach) you want to use for executing your model training code.

-  ``toolkit_version`` RL toolkit version you want to be use for executing your model training code.

-  ``framework`` Framework (MXNet or TensorFlow) you want to be used as
   a toolkit backed for reinforcement learning training.

or provide:

-  ``image_uri`` An alternative Docker image to use for training and
   serving.  If specified, the estimator will use this image for training and
   hosting, instead of selecting the appropriate SageMaker official image based on
   framework_version and py_version. Refer to: `SageMaker RL Docker Containers
   <#sagemaker-rl-docker-containers>`_ for details on what the Official images support
   and where to find the source code to build your custom image.


Optional arguments
~~~~~~~~~~~~~~~~~~

When you create an ``RLEstimator`` object, you can specify a number of optional arguments.
For more information, see :class:`sagemaker.rl.estimator.RLEstimator`.

Calling fit
~~~~~~~~~~~

You start your training script by calling ``fit`` on an ``RLEstimator``.
For more information about what arguments can be passed to ``fit``, see :func:`sagemaker.estimator.EstimatorBase.fit`.

Distributed RL Training
-----------------------

Amazon SageMaker RL supports multi-core and multi-instance distributed training.
Depending on your use case, training and/or environment rollout can be distributed.

Please see the `Amazon SageMaker examples <https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning>`_
on how it can be done using different RL toolkits.


Saving models
-------------

In order to save your trained PyTorch model for deployment on SageMaker, your training script should save your model
to a certain filesystem path ``/opt/ml/model``. This value is also accessible through the environment variable
``SM_MODEL_DIR``.

Deploying RL Models
-------------------

After an RL Estimator has been fit, you can host the newly created model in SageMaker.

After calling ``fit``, you can call ``deploy`` on an ``RLEstimator`` Estimator to create a SageMaker Endpoint.
The Endpoint runs one of the SageMaker-provided model server based on the ``framework`` parameter
specified in the ``RLEstimator`` constructor and hosts the model produced by your training script,
which was run when you called ``fit``. This was the model you saved to ``model_dir``.
In case if ``image_uri`` was specified it would use provided image for the deployment.

``deploy`` returns a ``sagemaker.mxnet.MXNetPredictor`` for MXNet or
``sagemaker.tensorflow.TensorFlowPredictor`` for TensorFlow.

``predict`` returns the result of inference against your model.

.. code:: python

    # Train my estimator
    rl_estimator = RLEstimator(entry_point='coach-train.py',
                               toolkit=RLToolkit.COACH,
                               toolkit_version='0.11.0',
                               framework=RLFramework.MXNET,
                               role='SageMakerRole',
                               instance_type='ml.c4.2xlarge',
                               instance_count=1)

    rl_estimator.fit()

    # Deploy my estimator to a SageMaker Endpoint and get a MXNetPredictor
    predictor = rl_estimator.deploy(instance_type='ml.m4.xlarge',
                                    initial_instance_count=1)

    response = predictor.predict(data)

For more information please see `The SageMaker MXNet Model Server <https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#the-sagemaker-mxnet-model-server>`_
and `Deploying to TensorFlow Serving Endpoints <deploying_tensorflow_serving.html>`_ documentation.


Working with Existing Training Jobs
-----------------------------------

Attaching to existing training jobs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

You can attach an RL Estimator to an existing training job using the
``attach`` method.

.. code:: python

    my_training_job_name = 'MyAwesomeRLTrainingJob'
    rl_estimator = RLEstimator.attach(my_training_job_name)

After attaching, if the training job has finished with job status "Completed", it can be
``deploy``\ ed to create a SageMaker Endpoint and return a ``Predictor``. If the training job is in progress,
attach will block and display log messages from the training job, until the training job completes.

The ``attach`` method accepts the following arguments:

-  ``training_job_name:`` The name of the training job to attach
   to.
-  ``sagemaker_session:`` The Session used
   to interact with SageMaker

RL Training Examples
--------------------

Amazon provides several example Jupyter notebooks that demonstrate end-to-end training on Amazon SageMaker using RL.
Please refer to:

https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning

These are also available in SageMaker Notebook Instance hosted Jupyter notebooks under the sample notebooks folder.


SageMaker RL Docker Containers
------------------------------

For more about the Docker images themselves, visit `the SageMaker RL containers repository <https://github.com/aws/sagemaker-rl-container>`_.