Crea un'immagine del contenitore Docker personalizzata SageMaker e usala per l'addestramento dei modelli in AWS Step Functions

Configura Amazon ECR e crea un nuovo registro privato.

Se non l'hai già fatto, configura Amazon ECR seguendo le istruzioni in Configurazione con Amazon ECR nella Amazon ECR User Guide. Ogni AWS account è dotato di un ECR registro Amazon privato predefinito.

Crea un repository ECR privato Amazon.

Segui le istruzioni riportate nella sezione Creazione di un repository privato nella Amazon ECR User Guide.

Nota: il repository che crei è il luogo in cui archivierai le immagini personalizzate dei contenitori Docker.

Crea un Dockerfile che includa le specifiche necessarie per eseguire il SageMaker processo di elaborazione.

Crea un Dockerfile che includa le specifiche necessarie per eseguire il SageMaker processo di elaborazione configurando un Dockerfile. Per istruzioni, consulta Adattamento del proprio contenitore di formazione nella Amazon SageMaker Developer Guide.

Per ulteriori informazioni su Dockerfiles, consulta il Dockerfile Reference nella documentazione Docker.

Esempio di celle di codice del notebook Jupyter per creare un Dockerfile

Cella 1

# Make docker folder
!mkdir -p docker

Cella 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"]

Crea l'immagine del tuo contenitore Docker e inviala ad AmazonECR.

Per ulteriori informazioni, consulta Creazione e registrazione del contenitore in Costruire il proprio contenitore di algoritmi su GitHub.

Esempio di celle di codice per notebook Jupyter per creare e registrare un'immagine Docker

Importante: prima di eseguire le seguenti celle, assicurati di aver creato un Dockerfile e di averlo archiviato nella directory chiamata. docker Inoltre, assicurati di aver creato un ECR repository Amazon e di sostituire il ecr_repository valore nella prima cella con il nome del repository.

Cella 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)

Cella 2

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

Cella 3

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

Cella 4

# Push docker image
!docker push $image_uri

Nota: è necessario autenticare il client Docker nel registro privato in modo da poter utilizzare i comandi docker push anddocker pull. Questi comandi inviano ed estraggono immagini da e verso gli archivi del registro.

Crea uno script Python che includa la tua logica di elaborazione personalizzata e di addestramento dei modelli.

Scrivi una logica di elaborazione personalizzata da eseguire nello script di elaborazione dei dati. Quindi, salvalo come script Python denominato. training.py

Per ulteriori informazioni, consulta Bring your own model with SageMaker Script Mode on GitHub.

Esempio di script Python che include l'elaborazione personalizzata e la logica di addestramento dei modelli

%%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)

Crea un flusso di lavoro Step Functions che includa il tuo job SageMaker Processing come uno dei passaggi.

Installa e importa AWSStep Functions Data Science SDK e carica il file training.py su Amazon S3. Quindi, usa Amazon SageMaker Python SDK per definire una fase di elaborazione in Step Functions.

Importante: assicurati di aver creato un ruolo di IAM esecuzione per Step Functions nel tuo AWS account.

Esempio di configurazione dell'ambiente e script di formazione personalizzato da caricare su 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",
)

Esempio di definizione della fase di SageMaker elaborazione che utilizza un'ECRimmagine Amazon personalizzata e uno script Python

Nota: assicurati di utilizzare il execution_input parametro per specificare il nome del lavoro. Il valore del parametro deve essere univoco ogni volta che viene eseguito il processo. Inoltre, il codice del file training.py viene passato come input parametro aProcessingStep, il che significa che verrà copiato all'interno del contenitore. La destinazione del ProcessingInput codice è la stessa del secondo argomento all'container_entrypointinterno di.

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"],
)

Esempio di flusso di lavoro Step Functions che esegue un SageMaker processo di elaborazione

Nota: questo flusso di lavoro di esempio include solo la fase del processo di SageMaker elaborazione, non un flusso di lavoro Step Functions completo. Per un esempio completo di flusso di lavoro, consulta Notebooks di esempio SageMaker nella documentazione di AWS Step Functions Data Science. SDK

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)