Erstellen Sie ein benutzerdefiniertes Docker-Container-Image für SageMaker und verwenden Sie es für Modelltrainings in AWS Step Functions

Richten Sie Amazon ECR ein und erstellen Sie eine neue private Registrierung.

Falls Sie dies noch nicht getan haben, richten Sie Amazon ECR ein, indem Sie den Anweisungen unter Einrichtung mit Amazon ECR im Amazon ECR-Benutzerhandbuch folgen. Jedes AWS-Konto ist mit einer standardmäßigen privaten Amazon ECR-Registrierung ausgestattet.

Erstellen Sie ein privates Amazon ECR-Repository.

Folgen Sie den Anweisungen unter Erstellen eines privaten Repositorys im Amazon ECR-Benutzerhandbuch.

Hinweis: In dem Repository, das Sie erstellen, speichern Sie Ihre benutzerdefinierten Docker-Container-Images.

Erstellen Sie ein Dockerfile, das die Spezifikationen enthält, die für die Ausführung Ihres SageMaker Verarbeitungsjobs erforderlich sind.

Erstellen Sie ein Dockerfile, das die für die Ausführung Ihres SageMaker Verarbeitungsjobs erforderlichen Spezifikationen enthält, indem Sie ein Dockerfile konfigurieren. Eine Anleitung finden Sie im Amazon SageMaker Developer Guide unter Anpassung Ihres eigenen Trainingscontainers.

Weitere Informationen zu Dockerfiles finden Sie in der Dockerfile-Referenz in der Docker-Dokumentation.

Beispiel: Jupyter-Notebook-Codezellen zum Erstellen eines Dockerfiles

Zelle 1

# Make docker folder
!mkdir -p docker

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

Erstellen Sie Ihr Docker-Container-Image und übertragen Sie es auf Amazon ECR.

Weitere Informationen finden Sie unter Container erstellen und registrieren unter Erstellen eines eigenen Algorithmus-Containers auf GitHub.

Beispiel für Jupyter-Notebook-Codezellen zum Erstellen und Registrieren eines Docker-Images

Wichtig: Bevor Sie die folgenden Zellen ausführen, stellen Sie sicher, dass Sie ein Dockerfile erstellt und im Verzeichnis namens gespeichert haben. docker Stellen Sie außerdem sicher, dass Sie ein Amazon ECR-Repository erstellt haben und dass Sie den ecr_repository Wert in der ersten Zelle durch den Namen Ihres Repositorys ersetzen.

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

Zelle 2

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

Zelle 3

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

Zelle 4

# Push docker image
!docker push $image_uri

Hinweis: Sie müssen Ihren Docker-Client bei Ihrer privaten Registrierung authentifizieren, damit Sie die Befehle docker push und docker pull verwenden können. Mit diesen Befehlen werden Bilder in und aus den Repositorys in Ihrer Registrierung übertragen und abgerufen.

Erstellen Sie ein Python-Skript, das Ihre benutzerdefinierte Verarbeitungs- und Modelltrainingslogik enthält.

Schreiben Sie eine benutzerdefinierte Verarbeitungslogik, die in Ihrem Datenverarbeitungsskript ausgeführt werden soll. Speichern Sie es dann als Python-Skript mit dem Namentraining.py.

Weitere Informationen finden Sie unter Bringen Sie Ihr eigenes Modell mit aktiviertem SageMaker Skriptmodus mit GitHub.

Beispiel für ein Python-Skript, das benutzerdefinierte Verarbeitungs- und Modelltrainingslogik enthält

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

Erstellen Sie einen Step Functions Functions-Workflow, der Ihren SageMaker Verarbeitungsjob als einen der Schritte enthält.

Installieren und importieren Sie das AWS Step Functions Data Science SDK und laden Sie die Datei training.py auf Amazon S3 hoch. Verwenden Sie dann das Amazon SageMaker Python SDK, um einen Verarbeitungsschritt in Step Functions zu definieren.

Wichtig: Stellen Sie sicher, dass Sie in Ihrem AWS-Konto eine IAM-Ausführungsrolle für Step Functions erstellt haben.

Beispiel für die Einrichtung einer Umgebung und ein benutzerdefiniertes Trainingsskript zum Hochladen auf 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",
)

Beispiel für eine Definition eines SageMaker Verarbeitungsschritts, die ein benutzerdefiniertes Amazon ECR-Image und ein Python-Skript verwendet

Hinweis: Stellen Sie sicher, dass Sie den execution_input Parameter verwenden, um den Jobnamen anzugeben. Der Wert des Parameters muss bei jeder Ausführung des Jobs eindeutig sein. Außerdem wird der Code der Datei training.py als input Parameter an die übergebenProcessingStep, was bedeutet, dass er in den Container kopiert wird. Das Ziel für den ProcessingInput Code ist dasselbe wie das zweite Argument in dercontainer_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"],
)

Beispiel Step Functions Functions-Workflow, der einen SageMaker Verarbeitungsjob ausführt

Hinweis: Dieser Beispiel-Workflow umfasst nur den SageMaker Verarbeitungs-Job-Schritt, keinen vollständigen Step Functions Functions-Workflow. Ein vollständiges Beispiel für einen Workflow finden Sie unter Beispiel-Notebooks SageMaker in der AWS Step Functions Data Science SDK-Dokumentation.

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)