Crea un'immagine di contenitore Docker personalizzata SageMaker e usala per l'addestramento dei modelli in AWS Step Functions - Prontuario AWS
RiepilogoPrerequisiti e limitazioniArchitetturaStrumentiEpicheRisorse correlate

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

Creato da Julia Bluszcz (AWS), Neha Sharma (AWS), Aubrey Oosthuizen (AWS), Mohan Gowda Purushothama (AWS) e Mateusz Zaremba (AWS)

Ambiente: produzione

Tecnologie: apprendimento automatico e intelligenza artificiale; DevOps

Servizi AWS: Amazon ECR; Amazon SageMaker; AWS Step Functions

Riepilogo

Questo modello mostra come creare un'immagine di contenitore Docker per Amazon SageMaker e utilizzarla per un modello di formazione in AWS Step Functions. Impacchettando algoritmi personalizzati in un contenitore, puoi eseguire quasi tutto il codice nell' SageMaker ambiente, indipendentemente dal linguaggio di programmazione, dal framework o dalle dipendenze.

Nel SageMaker notebook di esempio fornito, l'immagine del contenitore Docker personalizzato viene archiviata in Amazon Elastic Container Registry (Amazon ECR). Step Functions utilizza quindi il contenitore archiviato in Amazon ECR per eseguire uno script di elaborazione Python per. SageMaker Quindi, il contenitore esporta il modello in Amazon Simple Storage Service (Amazon S3).

Prerequisiti e limitazioni

Prerequisiti

Versioni del prodotto

  • SDK AWS Step Functions Data Science versione 2.3.0

  • SDK Amazon SageMaker Python versione 2.78.0

Architettura

Il diagramma seguente mostra un esempio di flusso di lavoro per creare un'immagine di contenitore Docker per SageMaker, quindi utilizzarla per un modello di addestramento in Step Functions:

Flusso di lavoro per creare un'immagine del contenitore Docker SageMaker da utilizzare come modello di formazione Step Functions.

Il diagramma mostra il flusso di lavoro seguente:

  1. Un data scientist o un DevOps ingegnere utilizza un SageMaker notebook Amazon per creare un'immagine di contenitore Docker personalizzata.

  2. Un data scientist o un DevOps ingegnere archivia l'immagine del contenitore Docker in un repository privato Amazon ECR che si trova in un registro privato.

  3. Un data scientist o un DevOps ingegnere utilizza il contenitore Docker per eseguire un processo di elaborazione SageMaker Python in un flusso di lavoro Step Functions.

Automazione e scalabilità

Il SageMaker notebook di esempio in questo modello utilizza un tipo di istanza di ml.m5.xlarge notebook. È possibile modificare il tipo di istanza in base al proprio caso d'uso. Per ulteriori informazioni sui tipi di istanze SageMaker notebook, consulta la pagina SageMaker dei prezzi di Amazon.

Strumenti

  • Amazon Elastic Container Registry (Amazon ECR) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile.

  • Amazon SageMaker è un servizio di machine learning (ML) gestito che ti aiuta a creare e addestrare modelli di machine learning per poi distribuirli in un ambiente ospitato pronto per la produzione.

  • Amazon SageMaker Python SDK è una libreria open source per la formazione e la distribuzione di modelli di apprendimento automatico su. SageMaker

  • AWS Step Functions è un servizio di orchestrazione serverless che ti aiuta a combinare le funzioni di AWS Lambda e altri servizi AWS per creare applicazioni aziendali critiche.

  • AWS Step Functions Data Science Python SDK è una libreria open source che ti aiuta a creare flussi di lavoro Step Functions che elaborano e pubblicano modelli di machine learning.

Epiche

AttivitàDescrizioneCompetenze richieste

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 account AWS è dotato di un registro Amazon ECR privato predefinito.

DevOps ingegnere

Crea un repository privato Amazon ECR.

Segui le istruzioni in 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.

DevOps ingegnere

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"]
DevOps ingegnere

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

  1. Crea l'immagine del contenitore utilizzando il Dockerfile che hai creato eseguendo il docker build comando nella CLI di AWS.

  2. Invia l'immagine del contenitore ad Amazon ECR eseguendo il docker push comando.

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 repository Amazon ECR 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.

DevOps ingegnere
AttivitàDescrizioneCompetenze richieste

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)
Data scientist

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

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

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

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'immagine Amazon ECR 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 dell'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)
Data scientist

Risorse correlate