Cree una imagen de contenedor Docker personalizada SageMaker y úsela para el entrenamiento de modelos en AWS Step Functions

Configura Amazon ECR y crea un nuevo registro privado.

Si aún no lo has hecho, configura Amazon ECR siguiendo las instrucciones de Configuración con Amazon ECR en la Guía del ECR usuario de Amazon. Cada AWS cuenta cuenta con un ECR registro de Amazon privado predeterminado.

Crea un repositorio ECR privado de Amazon.

Sigue las instrucciones de Crear un repositorio privado en la Guía del ECR usuario de Amazon.

Nota: El repositorio que cree es donde almacenará sus imágenes de contenedores de Docker personalizadas.

Cree un Dockerfile que incluya las especificaciones necesarias para ejecutar su trabajo de SageMaker procesamiento.

Cree un Dockerfile que incluya las especificaciones necesarias para ejecutar su trabajo de SageMaker procesamiento configurando un Dockerfile. Para obtener instrucciones, consulta Cómo adaptar tu propio contenedor de formación en la Guía para SageMaker desarrolladores de Amazon.

Para obtener más información sobre Dockerfiles, consulta la referencia de Dockerfile en la documentación de Docker.

Ejemplo de celdas de código de un cuaderno de Jupyter para crear un Dockerfile

Celda 1

# Make docker folder
!mkdir -p docker

Celda 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 tu imagen de contenedor de Docker y envíala a AmazonECR.

Para obtener más información, consulta Cómo crear y registrar el contenedor en Cómo crear tu propio algoritmo en un contenedor GitHub.

Ejemplo de celdas de código del cuaderno de Jupyter para crear y registrar una imagen de Docker

Importante: antes de ejecutar las siguientes celdas, asegúrate de haber creado un Dockerfile y de haberlo guardado en el directorio denominado docker. Además, asegúrate de haber creado un ECR repositorio de Amazon y de reemplazar el ecr_repository valor de la primera celda por el nombre de tu repositorio.

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

Celda 2

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

Celda 3

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

Celda 4

# Push docker image
!docker push $image_uri

Nota: Debe autenticar su cliente de Docker en su registro privado para poder utilizar los comandos docker push y docker pull. Estos comandos envían y extraen imágenes de los repositorios de su registro y las extraen de ellos.

Cree un script de Python que incluya su procesamiento personalizado y su lógica de capacitación de modelos.

Escriba una lógica de procesamiento personalizada para ejecutarla en su script de procesamiento de datos. A continuación, guárdelo como un script de Python denominado training.py.

Para obtener más información, consulte Utilice su propio modelo con el modo SageMaker script activado GitHub.

Ejemplo de script de Python que incluye procesamiento personalizado y lógica de capacitación 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)

Cree un flujo de trabajo de Step Functions que incluya su trabajo de SageMaker procesamiento como uno de los pasos.

Instale e importe AWSStep Functions Data Science SDK y cargue el archivo training.py en Amazon S3. A continuación, utilice Amazon SageMaker Python SDK para definir un paso de procesamiento en Step Functions.

Importante: Asegúrese de haber creado un rol de IAM ejecución para Step Functions en su AWS cuenta.

Ejemplo de configuración del entorno y script de capacitación personalizado para cargarlo en 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",
)

Ejemplo SageMaker de definición de paso de procesamiento que utiliza una ECR imagen personalizada de Amazon y un script de Python

Nota: Asegúrese de utilizar el parámetro execution_input para especificar el nombre del trabajo. El valor del parámetro debe ser único cada vez que se ejecute el trabajo. Además, el código del archivo training.py se pasa como parámetro input a ProcessingStep, lo que significa que se copiará dentro del contenedor. El destino del código ProcessingInput es el mismo que el del segundo argumento incluido en 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"],
)

Ejemplo de flujo de trabajo de Step Functions que ejecuta un trabajo SageMaker de procesamiento

Nota: Este flujo de trabajo de ejemplo incluye solo el paso del trabajo de SageMaker procesamiento, no un flujo de trabajo completo de Step Functions. Para ver un ejemplo completo de flujo de trabajo, consulte Cuadernos de ejemplo SageMaker en la SDK documentación de Ciencia de Datos de 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)