Créez une image de conteneur Docker personnalisée SageMaker et utilisez-la pour l'entraînement 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 du guide de ECR l'utilisateur Amazon. Chaque AWS compte est associé à un ECR registre Amazon privé par défaut.

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

Suivez les instructions de la section Création d'un dépôt privé dans le guide de ECR l'utilisateur Amazon.

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 pour exécuter 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 sur AmazonECR.

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 ECR référentiel Amazon 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.

Écrivez 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 AWSStep Functions Data Science SDK et chargez le fichier training.py sur Amazon S3. Utilisez ensuite Amazon SageMaker Python SDK pour définir une étape de traitement dans Step Functions.

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

Exemple de configuration d'environnement et 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 ECR image Amazon 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 ducontainer_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, voir Example notebooks SageMaker dans la SDK documentation de 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)