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

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

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

Erstellen Sie ein ECR privates Amazon-Repository.

Folgen Sie den Anweisungen unter Erstellen eines privaten Repositorys im ECRAmazon-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 an AmazonECR.

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 ECR Amazon-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 mit benutzerdefinierter Verarbeitungs- und Modelltrainingslogik

%%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 AWSStep Functions Data Science SDK und laden Sie die Datei training.py auf Amazon S3 hoch. Verwenden Sie dann 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 ECR Amazon-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. Einen vollständigen Beispiel-Workflow finden Sie unter Beispiel-Notebooks SageMaker in der Data SDK Science-Dokumentation von 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)