Customizing your Cloud Based mostly Machine Studying Coaching Surroundings — Half 2 | by Chaim Rand | Might, 2023

Extra options for rising your growth flexibility

Picture by Murilo Gomes on Unsplash

That is the second a part of a two-part submit on the subject of customizing your cloud-based AI mannequin coaching atmosphere. Within the first part, a prerequisite for this half, we launched the battle that will come up between the need to make use of a pre-built specially-designed coaching atmosphere and the requirement that we now have the flexibility to customise the atmosphere to our venture’s wants. The important thing to discovering potential alternatives for personalisation is a deep understanding of the end-to-end movement of operating a coaching job within the cloud. We described this movement for the managed Amazon SageMaker coaching service whereas emphasizing the worth of analyzing the publicly obtainable underlying supply code. We then offered the primary technique for personalisation — putting in pip bundle dependencies on the very starting of the coaching session — and demonstrated its limitations.

On this submit we are going to current two further strategies. Each strategies contain creating our personal customized Docker picture, however they’re essentially completely different of their method. The primary technique makes use of an official cloud-service offered picture and expands it in line with the venture wants. The second takes a consumer outlined (cloud agnostic) Docker picture and extends it to help coaching within the cloud. As we are going to see, every has its professionals and cons and the most suitable choice will extremely rely upon the main points of your venture.

Creating a completely purposeful, efficiency optimum, Docker picture for coaching on a cloud-based GPU may be painstaking, requiring navigation of a large number of intertwined HW and SW dependencies. Doing this for all kinds of coaching use instances and HW platforms is much more troublesome. Reasonably than try to do that on our personal, our first alternative will at all times be to benefit from the pre-defined picture created for us by the cloud service supplier. If we have to customise this picture, we are going to merely create a brand new Dockerfile that extends the official picture and provides the required dependencies.

The AWS Deep Learning Container (DLC) github repository contains instructions for extending an official AWS DLC. This requires logging in to entry the Deep Studying Containers picture repository with the intention to pull the picture, construct the prolonged picture, after which add it to an Amazon Elastic Container Registry (ECR) in your account.

The next code block demonstrates tips on how to lengthen the official AWS DLC from our SageMaker instance (partly 1). We present three sorts of extensions:

  1. Linux Bundle: We set up Nvidia Nsight Systems for superior GPU profiling of our coaching jobs.
  2. Conda Bundle: We set up the S5cmd conda bundle which we use for pulling information recordsdata from cloud storage.
  3. Pip Bundle: We set up a particular model of the opencv-python pip bundle.

# set up nsys
ADD ./
RUN apt set up -y ./NsightSystems-linux-cli-public-2023.1.1.127-3236574.deb

# set up s5cm
RUN conda set up -y s5cmd

# set up opencv
RUN pip set up opencv-python==

For extra particulars on extending the official AWS DLC, together with tips on how to add the resultant picture to ECR, see here. The code block under reveals tips on how to modify the coaching job deployment script to make use of the prolonged picture:

from sagemaker.pytorch import PyTorch

# outline the coaching job
estimator = PyTorch(
function='<arn function>',
image_uri = '<account-number><tag>'

An analogous choice you’ve gotten for customizing an official picture, assuming you’ve gotten entry to its corresponding Dockerfile, is to easily make the specified edits to the Dockerfile and construct from scratch. For AWS DLC, this feature is documented here. Nevertheless, take into account that though primarily based on the identical Dockerfile, the resultant picture may differ as a result of variations within the construct atmosphere and up to date bundle variations.

Surroundings customization through extension of an official Docker picture is a good way to get essentially the most out of the absolutely purposeful, absolutely validated, cloud-optimal coaching atmosphere predefined by the cloud service whereas nonetheless permitting you the liberty and suppleness to make the additions and variations you require. Nevertheless, this feature additionally has its limitations as we exhibit through instance.

Coaching in a Consumer Outlined Python Surroundings

For quite a lot of causes, you might require the flexibility to coach in a user-defined Python atmosphere. This could possibly be for the sake of reproducibility, platform independence, security/safety/compliance concerns, or another function. One choice you may think about could be to increase an official Docker picture along with your customized Python atmosphere. That method you can, on the very least, profit from the platform associated installations and optimizations from the picture. Nevertheless, this might get form of tough in case your meant use depends on some type of Python primarily based automation. For instance, in a managed coaching atmosphere, the Dockerfile ENTRYPOINT runs a Python script that performs every kind of actions together with downloading the code supply listing from cloud storage, putting in Python dependencies, operating the consumer outlined coaching script, and extra. This Python script resides within the predefined Python atmosphere of the official Docker picture. Programming the automated script to begin up the coaching script in a separate Python atmosphere is doable however may require some handbook code modifications within the predefined atmosphere and will get very messy. Within the subsequent part we are going to exhibit a cleaner method of doing this.

The ultimate situation we think about is one wherein you’re required to coach in a particular atmosphere outlined by your individual Docker picture. As earlier than, the drive for this could possibly be regulatory, or the will to run with the identical picture within the cloud as you do domestically (“on-prem”). Some cloud companies present the flexibility to deliver your individual user-defined picture and adapt it to be used within the cloud. On this part we exhibit two methods wherein Amazon SageMaker helps this.

BYO Possibility 1: The SageMaker Coaching Toolkit

The primary choice, documented here, means that you can add the specialised (managed) coaching start-up movement we described in part 1 into you customized Python atmosphere. This basically allows you to practice in SageMaker utilizing your customized picture in the identical method in which you’d use an official picture. Specifically, you possibly can re-use the identical picture for a number of tasks/experiments and depend on the SageMaker APIs to obtain the experiment-specific code into the coaching atmosphere at start-up (as described in part 1). You do not want to create and add a brand new picture each time you modify your coaching code.

The code block under demonstrates tips on how to take a customized picture and improve it with the SageMaker training toolkit following the directions detailed here.

FROM user_defined_docker_image

RUN echo "conda activate user_defined_conda_env" >> ~/.bashrc
SHELL ["/bin/bash", "--login", "-c"]

ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.coaching:fundamental
RUN conda activate user_defined_conda_env
&& pip set up --no-cache-dir -U sagemaker-pytorch-training sagemaker-training

# sagemaker makes use of jq to compile executable
RUN apt-get replace
&& apt-get -y improve --only-upgrade systemd
&& apt-get set up -y --allow-change-held-packages --no-install-recommends

# SageMaker assumes conda atmosphere is in Path
ENV PATH /choose/conda/envs/user_defined_conda_env/bin:$PATH

# delete entry level and args if offered by father or mother Dockerfile
CMD []

BYO Possibility 2: Configuring the Entrypoint

The second choice, documented here, means that you can practice in SageMaker in a user-defined Docker atmosphere with zero modifications to the Docker picture. All that’s required is to explicitly set the ENTRYPOINT instruction of the Docker container. One of many methods to do that (as documented here) is to move in ContainerEntrypoint and/or ContainerArguments parameters to the AlgorithmSpecification of the API request. Sadly, as of the time of this writing, this feature is just not supported by the SageMaker Python API (model 2.146.1). Nevertheless, we will simply allow this by extending the SageMaker Session class as demonstrated within the code block under:

from sagemaker.session import Session

# custom-made session class that helps including container entrypoint settings
class SessionEx(Session):
def __init__(self, **kwargs):
self.user_entrypoint = kwargs.pop('entrypoint', None)
self.user_arguments = kwargs.pop('arguments', None)
tremendous(SessionEx, self).__init__(**kwargs)

def _get_train_request(self, **kwargs):
train_request = tremendous(SessionEx, self)._get_train_request(**kwargs)
if self.user_entrypoint:
train_request["AlgorithmSpecification"]["ContainerEntrypoint"] =
if self.user_arguments:
train_request["AlgorithmSpecification"]["ContainerArguments"] =
return train_request

from sagemaker.pytorch import PyTorch

# create session with consumer outlined entrypoint and arguments
# SageMaker will run 'docker run --entrypoint python <consumer picture>
sm_session = SessionEx(user_entrypoint='python',

# outline the coaching job
estimator = PyTorch(
function='<arn function>',

Optimizing Your Docker Picture

One of many disadvantages of the BYO choice is that you just lose the chance to profit from the specialization of the official pre-defined picture. You may manually and selectively reintroduce a few of these into your customized picture. For instance, the SageMaker documentation contains detailed instructions for integrating help for Amazon EFA. Furthermore, you at all times have the choice of trying again on the publicly obtainable Dockerfile to cherry choose what you need.

On this two-part submit we now have mentioned completely different strategies for customizing your cloud-based coaching atmosphere. The strategies we selected have been meant to exhibit methods of addressing several types of use instances. In observe, the very best resolution will instantly rely in your venture wants. You may determine to create a single customized Docker picture for all your coaching experiments and mix this with an choice to put in experiment-specific dependencies (utilizing the primary technique). You may discover {that a} completely different technique, not mentioned right here, e.g., one which includes tweaking some portion of the sagemaker-training Python bundle, to raised fit your wants. The underside line is that when you find yourself confronted with a have to customise your coaching atmosphere — you’ve gotten choices; and if the usual choices we now have lined don’t suffice, don’t despair, get artistic!

Related Articles

Leave a Reply

Your email address will not be published. Required fields are marked *

Back to top button