| ========================================================== |
| 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>`_. |
|
|
