Crie uma imagem de contêiner Docker personalizada SageMaker e use-a para treinamento de modelos no AWS Step Functions

Configure o Amazon ECR e crie um novo registro privado.

Se você ainda não o fez, configure o Amazon ECR seguindo as instruções em Configuração com o Amazon ECR no Guia do usuário do Amazon ECR. Cada conta da AWS é fornecida com um registro privado padrão do Amazon ECR.

Crie um repositório privado do Amazon ECR.

Siga as instruções em Criação de um repositório privado no Guia do usuário do Amazon ECR.

Observação: o repositório que você cria é onde você armazenará suas imagens personalizadas de contêiner do Docker.

Crie um Dockerfile que inclua as especificações necessárias para executar seu trabalho de SageMaker processamento.

Crie um Dockerfile que inclua as especificações necessárias para executar seu trabalho de SageMaker processamento configurando um Dockerfile. Para obter instruções, consulte Adaptar seu próprio contêiner de treinamento no Amazon SageMaker Developer Guide.

Para obter mais informações sobre Dockerfiles, consulte a Referência do Dockerfile na documentação do Docker.

Exemplo de células de código do caderno Jupyter para criar um Dockerfile

Célula 1

# Make docker folder
!mkdir -p docker

Célula 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"]

Crie a imagem do contêiner do Docker e envie-a para o Amazon ECR.

Para obter mais informações, consulte Criação e registro do contêiner em Criando seu próprio contêiner de algoritmo em GitHub.

Exemplo de células de código do caderno Jupyter para criar e registrar uma imagem do Docker

Importante: antes de executar as células a seguir, verifique se você criou um Dockerfile e o armazenou no diretório chamado docker. Além disso, certifique-se de ter criado um repositório Amazon ECR e de substituir o valor ecr_repository na primeira célula pelo nome do seu repositório.

Célula 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)

Célula 2

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

Célula 3

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

Célula 4

# Push docker image
!docker push $image_uri

Nota: você deve autenticar seu cliente Docker em seu registro privado para poder usar os comandos docker push e docker pull. Esses comandos enviam e extraem imagens de e para os repositórios em seu registro.

Crie um script Python que inclua sua lógica personalizada de processamento e treinamento de modelos.

Escreva uma lógica de processamento personalizada para ser executada em seu script de processamento de dados. Em seguida, salve-o como um script Python chamado training.py.

Para obter mais informações, consulte Traga seu próprio modelo com o Modo de SageMaker script ativado GitHub.

Exemplo de script Python que inclui processamento personalizado e lógica de treinamento de modelos

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

Crie um fluxo de trabalho do Step Functions que inclua sua tarefa de SageMaker processamento como uma das etapas.

Instale e importe o AWS Step Functions Data Science SDK e faça o upload do arquivo training.py para o Amazon S3. Em seguida, use o Amazon SageMaker Python SDK para definir uma etapa de processamento em Step Functions.

Importante: certifique-se de ter criado uma função de execução do IAM para Step Functions em sua conta da AWS.

Exemplo de configuração de ambiente e script de treinamento personalizado para upload para o 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",
)

Exemplo SageMaker de definição de etapa de processamento que usa uma imagem personalizada do Amazon ECR e um script Python

Nota: certifique-se de usar o parâmetro execution_input para especificar o nome do trabalho. O valor do parâmetro deve ser exclusivo sempre que a tarefa for executada. Além disso, o código do arquivo training.py é passado como um parâmetro input para o ProcessingStep, o que significa que ele será copiado dentro do contêiner. O destino do código ProcessingInput é o mesmo do segundo argumento dentro do container_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"],
)

Exemplo de fluxo de trabalho do Step Functions que executa uma tarefa SageMaker de processamento

Nota: Esse exemplo de fluxo de trabalho inclui somente a etapa do trabalho de SageMaker processamento, não um fluxo de trabalho completo do Step Functions. Para ver um exemplo completo de fluxo de trabalho, consulte Exemplos de cadernos SageMaker na documentação do SDK de ciência de dados do AWS Step Functions.

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)