Stellen Sie mithilfe einer Inferenz-Pipeline in Amazon Vorverarbeitungslogik in einem ML-Modell an einem einzigen Endpunkt bereit SageMaker

Bereiten Sie den Datensatz für Ihre Regressionsaufgabe vor.

Öffnen Sie ein Notizbuch in Amazon SageMaker Studio.

Verwenden Sie den folgenden Beispielcode in Ihrem Notizbuch, um alle erforderlichen Bibliotheken zu importieren und Ihre Arbeitsumgebung zu initialisieren:

import sagemaker
from sagemaker import get_execution_role

sagemaker_session = sagemaker.Session()

# Get a SageMaker-compatible role used by this Notebook Instance.
role = get_execution_role()

# S3 prefix
bucket = sagemaker_session.default_bucket()
prefix = "Scikit-LinearLearner-pipeline-abalone-example"

Um einen Beispieldatensatz herunterzuladen, fügen Sie Ihrem Notizbuch den folgenden Code hinzu:

! mkdir abalone_data
! aws s3 cp s3://sagemaker-sample-files/datasets/tabular/uci_abalone/abalone.csv ./abalone_data

Hinweis: Das Beispiel in diesem Muster verwendet den Abalone-Datensatz aus dem UCI Machine Learning Repository.

Laden Sie den Datensatz in einen S3-Bucket hoch.

Fügen Sie in dem Notizbuch, in dem Sie Ihren Datensatz zuvor vorbereitet haben, den folgenden Code hinzu, um Ihre Beispieldaten in einen S3-Bucket hochzuladen:

WORK_DIRECTORY = "abalone_data"

train_input = sagemaker_session.upload_data(
    path="{}/{}".format(WORK_DIRECTORY, "abalone.csv"),
    bucket=bucket,
    key_prefix="{}/{}".format(prefix, "train"),
)

Bereiten Sie das Skript preprocessor.py vor.

Erstellen Sie das SkLearn-Präprozessor-Objekt.

Um ein SkLearn-Präprozessor-Objekt (genannt skLearn Estimator) zu erstellen, das Sie in Ihre endgültige Inferenz-Pipeline integrieren können, führen Sie den folgenden Code in Ihrem Notizbuch aus: SageMaker

from sagemaker.sklearn.estimator import SKLearn

FRAMEWORK_VERSION = "0.23-1"
script_path = "sklearn_abalone_featurizer.py"

sklearn_preprocessor = SKLearn(
    entry_point=script_path,
    role=role,
    framework_version=FRAMEWORK_VERSION,
    instance_type="ml.c4.xlarge",
    sagemaker_session=sagemaker_session,
)
sklearn_preprocessor.fit({"train": train_input})

Testen Sie die Inferenz des Präprozessors.

Um zu überprüfen, ob Ihr Präprozessor korrekt definiert ist, starten Sie einen Batch-Transformationsauftrag, indem Sie den folgenden Code in Ihr Notizbuch eingeben: SageMaker

# Define a SKLearn Transformer from the trained SKLearn Estimator
transformer = sklearn_preprocessor.transformer(
    instance_count=1, instance_type="ml.m5.xlarge", assemble_with="Line", accept="text/csv"
)


# Preprocess training input
transformer.transform(train_input, content_type="text/csv")
print("Waiting for transform job: " + transformer.latest_transform_job.job_name)
transformer.wait()
preprocessed_train = transformer.output_path

Erstellen Sie ein Modellobjekt.

Um ein Modellobjekt zu erstellen, das auf dem linearen Lernalgorithmus basiert, geben Sie den folgenden Code in Ihr SageMaker Notizbuch ein:

import boto3
from sagemaker.image_uris import retrieve

ll_image = retrieve("linear-learner", boto3.Session().region_name)
s3_ll_output_key_prefix = "ll_training_output"
s3_ll_output_location = "s3://{}/{}/{}/{}".format(
    bucket, prefix, s3_ll_output_key_prefix, "ll_model"
)

ll_estimator = sagemaker.estimator.Estimator(
    ll_image,
    role,
    instance_count=1,
    instance_type="ml.m4.2xlarge",
    volume_size=20,
    max_run=3600,
    input_mode="File",
    output_path=s3_ll_output_location,
    sagemaker_session=sagemaker_session,
)

ll_estimator.set_hyperparameters(feature_dim=10, predictor_type="regressor", mini_batch_size=32)

ll_train_data = sagemaker.inputs.TrainingInput(
    preprocessed_train,
    distribution="FullyReplicated",
    content_type="text/csv",
    s3_data_type="S3Prefix",
)

data_channels = {"train": ll_train_data}
ll_estimator.fit(inputs=data_channels, logs=True)

Der obige Code ruft das entsprechende Amazon ECR Docker-Image aus der öffentlichen Amazon ECR Registry für das Modell ab, erstellt ein Schätzerobjekt und verwendet dieses Objekt dann, um das Regressionsmodell zu trainieren.

Stellen Sie das Pipeline-Modell bereit.

Um ein Pipeline-Modellobjekt (d. h. ein Präprozessor-Objekt) zu erstellen und das Objekt bereitzustellen, geben Sie den folgenden Code in Ihr SageMaker Notizbuch ein:

from sagemaker.model import Model
from sagemaker.pipeline import PipelineModel
import boto3
from time import gmtime, strftime

timestamp_prefix = strftime("%Y-%m-%d-%H-%M-%S", gmtime())

scikit_learn_inferencee_model = sklearn_preprocessor.create_model()
linear_learner_model = ll_estimator.create_model()

model_name = "inference-pipeline-" + timestamp_prefix
endpoint_name = "inference-pipeline-ep-" + timestamp_prefix
sm_model = PipelineModel(
    name=model_name, role=role, models= [scikit_learn_inferencee_model, linear_learner_model]
)

sm_model.deploy(initial_instance_count=1, instance_type="ml.c4.xlarge", endpoint_name=endpoint_name)

Hinweis: Sie können den im Modellobjekt verwendeten Instanztyp an Ihre Bedürfnisse anpassen.

Testen Sie die Inferenz.

Um zu überprüfen, ob der Endpunkt ordnungsgemäß funktioniert, führen Sie den folgenden Beispiel-Inferenzcode in Ihrem SageMaker Notizbuch aus:

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer

payload = "M, 0.44, 0.365, 0.125, 0.516, 0.2155, 0.114, 0.155"
actual_rings = 10
predictor = Predictor(
    endpoint_name=endpoint_name, sagemaker_session=sagemaker_session, serializer=CSVSerializer()
)

print(predictor.predict(payload))