Créez une image de conteneur Docker personnalisée SageMaker et utilisez-la pour la formation des modèles dans AWS Step Functions

Configurez Amazon ECR et créez un nouveau registre privé.

Si ce n'est pas déjà fait, configurez Amazon ECR en suivant les instructions de la section Configuration avec Amazon ECR dans le guide de l'utilisateur Amazon ECR. Chaque compte AWS est associé à un registre Amazon ECR privé par défaut.

Créez un référentiel privé Amazon ECR.

Suivez les instructions de la section Création d'un référentiel privé dans le guide de l'utilisateur Amazon ECR.

Remarque : Le référentiel que vous créez est l'endroit où vous stockerez vos images de conteneur Docker personnalisées.

Créez un Dockerfile qui inclut les spécifications nécessaires à l'exécution de votre tâche de SageMaker traitement.

Créez un Dockerfile qui inclut les spécifications nécessaires pour exécuter votre tâche de SageMaker traitement en configurant un Dockerfile. Pour obtenir des instructions, consultez Adapter votre propre conteneur de formation dans le manuel Amazon SageMaker Developer Guide.

Pour plus d'informations sur Dockerfiles, consultez la référence Dockerfile dans la documentation Docker.

Exemple de cellules de code de bloc-notes Jupyter pour créer un Dockerfile

Cellule 1

# Make docker folder
!mkdir -p docker

Cellule 2

%%writefile docker/Dockerfile

FROM python:3.7-slim-buster

RUN pip3 install pandas==0.25.3 scikit-learn==0.21.3
ENV PYTHONUNBUFFERED=TRUE

ENTRYPOINT ["python3"]

Créez votre image de conteneur Docker et envoyez-la vers Amazon ECR.

Pour plus d'informations, voir Création et enregistrement du conteneur dans Création de votre propre conteneur d'algorithmes sur GitHub.

Exemple de cellules de code de bloc-notes Jupyter pour créer et enregistrer une image Docker

Important : Avant d'exécuter les cellules suivantes, assurez-vous d'avoir créé un Dockerfile et de l'avoir stocké dans le répertoire appelé. docker Assurez-vous également que vous avez créé un référentiel Amazon ECR et que vous remplacez la ecr_repository valeur de la première cellule par le nom de votre référentiel.

Cellule 1

import boto3
tag = ':latest'
account_id = boto3.client('sts').get_caller_identity().get('Account')
region = boto3.Session().region_name
ecr_repository = 'byoc'

image_uri = '{}.dkr.ecr.{}.amazonaws.com/{}'.format(account_id, region, ecr_repository + tag)

Cellule 2

# Build docker image
!docker build -t $image_uri docker

Cellule 3

# Authenticate to ECR
!aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin {account_id}.dkr.ecr.{region}.amazonaws.com

Cellule 4

# Push docker image
!docker push $image_uri

Remarque : vous devez authentifier votre client Docker auprès de votre registre privé afin de pouvoir utiliser les commandes docker push etdocker pull. Ces commandes envoient et extraient des images depuis et vers les référentiels de votre registre.

Créez un script Python qui inclut votre logique de traitement personnalisé et d'entraînement du modèle.

Rédigez une logique de traitement personnalisée à exécuter dans votre script de traitement des données. Ensuite, enregistrez-le sous la forme d'un script Python nommétraining.py.

Pour plus d'informations, voir Apportez votre propre modèle avec SageMaker le mode Script activé GitHub.

Exemple de script Python incluant un traitement personnalisé et une logique d'entraînement du modèle

%%writefile training.py
from numpy import empty
import pandas as pd
import os
from sklearn import datasets, svm
from joblib import dump, load


if __name__ == '__main__':
    digits = datasets.load_digits()
    #create classifier object
    clf = svm.SVC(gamma=0.001, C=100.)
    
    #fit the model
    clf.fit(digits.data[:-1], digits.target[:-1])
    
    #model output in binary format
    output_path = os.path.join('/opt/ml/processing/model', "model.joblib")
    dump(clf, output_path)

Créez un flux de travail Step Functions qui inclut votre tâche de SageMaker traitement comme l'une des étapes.

Installez et importez le SDK AWS Step Functions Data Science et chargez le fichier training.py sur Amazon S3. Utilisez ensuite le SDK Amazon SageMaker Python pour définir une étape de traitement dans Step Functions.

Important : assurez-vous d'avoir créé un rôle d'exécution IAM pour Step Functions dans votre compte AWS.

Exemple de configuration d'environnement et de script de formation personnalisé à télécharger sur Amazon S3

!pip install stepfunctions

import boto3
import stepfunctions
import sagemaker
import datetime

from stepfunctions import steps
from stepfunctions.inputs import ExecutionInput
from stepfunctions.steps import (
    Chain
)
from stepfunctions.workflow import Workflow
from sagemaker.processing import ScriptProcessor, ProcessingInput, ProcessingOutput

sagemaker_session = sagemaker.Session()
bucket = sagemaker_session.default_bucket() 
role = sagemaker.get_execution_role()
prefix = 'byoc-training-model'

# See prerequisites section to create this role
workflow_execution_role = f"arn:aws:iam::{account_id}:role/AmazonSageMaker-StepFunctionsWorkflowExecutionRole"

execution_input = ExecutionInput(
    schema={
        "PreprocessingJobName": str})


input_code = sagemaker_session.upload_data(
    "training.py",
    bucket=bucket,
    key_prefix="preprocessing.py",
)

Exemple SageMaker de définition d'étape de traitement utilisant une image Amazon ECR personnalisée et un script Python

Remarque : Assurez-vous d'utiliser le execution_input paramètre pour spécifier le nom de la tâche. La valeur du paramètre doit être unique à chaque exécution de la tâche. De plus, le code du fichier training.py est transmis en tant que input paramètre auProcessingStep, ce qui signifie qu'il sera copié dans le conteneur. La destination du ProcessingInput code est la même que celle du deuxième argument contenu dans lecontainer_entrypoint.

script_processor = ScriptProcessor(command=['python3'],
                image_uri=image_uri,
                role=role,
                instance_count=1,
                instance_type='ml.m5.xlarge')


processing_step = steps.ProcessingStep(
    "training-step",
    processor=script_processor,
    job_name=execution_input["PreprocessingJobName"],
    inputs=[
        ProcessingInput(
            source=input_code,
            destination="/opt/ml/processing/input/code",
            input_name="code",
        ),
    ],
    outputs=[
        ProcessingOutput(
            source='/opt/ml/processing/model', 
            destination="s3://{}/{}".format(bucket, prefix), 
            output_name='byoc-example')
    ],
    container_entrypoint=["python3", "/opt/ml/processing/input/code/training.py"],
)

Exemple de flux de travail Step Functions qui exécute une tâche SageMaker de traitement

Remarque : Cet exemple de flux de travail inclut uniquement l'étape de SageMaker traitement, et non un flux de travail Step Functions complet. Pour un exemple complet de flux de travail, consultez Example notebooks SageMaker dans la documentation du SDK AWS Step Functions Data Science.

workflow_graph = Chain([processing_step])

workflow = Workflow(
    name="ProcessingWorkflow",
    definition=workflow_graph,
    role=workflow_execution_role
)

workflow.create()
# Execute workflow
execution = workflow.execute(
    inputs={
        "PreprocessingJobName": str(datetime.datetime.now().strftime("%Y%m%d%H%M-%SS")),  # Each pre processing job (SageMaker processing job) requires a unique name,
    }
)
execution_output = execution.get_output(wait=True)