Implementa la logica di preelaborazione in un modello ML in un singolo endpoint utilizzando una pipeline di inferenza in Amazon SageMaker

Prepara il set di dati per l'attività di regressione.

Apri un notebook in Amazon SageMaker Studio.

Per importare tutte le librerie necessarie e inizializzare l'ambiente di lavoro, usa il seguente codice di esempio nel tuo notebook:

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"

Per scaricare un set di dati di esempio, aggiungi il seguente codice al tuo taccuino:

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

Nota: l'esempio in questo modello utilizza l'Abalone Data Set dell'UCI Machine Learning Repository.

Carica il set di dati in un bucket S3.

Nel taccuino in cui hai preparato il set di dati in precedenza, aggiungi il codice seguente per caricare i dati di esempio in un bucket S3:

WORK_DIRECTORY = "abalone_data"

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

Preparare lo script preprocessor.py.

Crea l'oggetto del preprocessore SKLearn.

Per creare un oggetto preprocessore SKLearn (chiamato SKLearn Estimator) da incorporare nella pipeline di inferenza finale, esegui il seguente codice nel tuo notebook: 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})

Verifica l'inferenza del preprocessore.

Per confermare che il preprocessore sia definito correttamente, avviate un processo di trasformazione in batch inserendo il seguente codice nel notebook: 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

Crea un oggetto modello.

Per creare un oggetto modello basato sull'algoritmo Linear Learner, inserisci il seguente codice nel tuo SageMaker taccuino:

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)

Il codice precedente recupera l'immagine Docker Amazon ECR pertinente dal registro Amazon ECR pubblico per il modello, crea un oggetto estimatore e quindi utilizza quell'oggetto per addestrare il modello di regressione.

Implementa il modello di pipeline.

Per creare un oggetto del modello di pipeline (ovvero un oggetto preprocessore) e distribuire l'oggetto, inserite il codice seguente nel vostro taccuino: SageMaker

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)

Nota: è possibile modificare il tipo di istanza utilizzato nell'oggetto del modello in base alle proprie esigenze.

Verificate l'inferenza.

Per confermare che l'endpoint funzioni correttamente, esegui il seguente codice di inferenza di esempio sul tuo notebook: SageMaker

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