Implemente la lógica de preprocesamiento en un modelo de aprendizaje automático en un único punto final mediante una canalización de inferencias en Amazon SageMaker

Prepare el conjunto de datos para la tarea de regresión.

Abre una libreta en Amazon SageMaker Studio.

Para importar todas las bibliotecas necesarias e inicializar su entorno de trabajo, utilice el siguiente código de ejemplo en su bloc de notas:

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"

Para descargar un conjunto de datos de muestra, añada el siguiente código a su bloc de notas:

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

Nota: El ejemplo de este patrón utiliza el conjunto de datos Abalone del UCI Machine Learning Repository.

Cargue el conjunto de datos en un bucket de S3.

En el bloc de notas en el que preparó su conjunto de datos anteriormente, añada el siguiente código para cargar los datos de muestra en un bucket de S3:

WORK_DIRECTORY = "abalone_data"

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

Prepare el script preprocessor.py.

Cree el objeto del preprocesador SKLearn.

Para crear un objeto preprocesador de SKLearn (denominado Estimator de SKLearn) que pueda incorporar a su proceso de inferencia final, ejecute el siguiente código en su bloc de notas: 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})

Pruebe la inferencia del preprocesador.

Para confirmar que su preprocesador está definido correctamente, inicie un trabajo de transformación por lotes introduciendo el siguiente código en su cuaderno: 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

Cree un objeto modelo.

Para crear un objeto modelo basado en el algoritmo de aprendizaje lineal, introduzca el siguiente código en su SageMaker bloc de notas:

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)

El código anterior recupera la imagen de Docker de Amazon ECR correspondiente del registro público de Amazon ECR del modelo, crea un objeto estimador y, a continuación, utiliza ese objeto para entrenar el modelo de regresión.

Implemente el modelo de canalización.

Para crear un objeto de modelo de canalización (es decir, un objeto de preprocesador) e implementar el objeto, introduzca el siguiente código en su SageMaker bloc de notas:

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: Puede ajustar el tipo de instancia utilizado en el objeto modelo para adaptarlo a sus necesidades.

Pruebe la inferencia.

Para confirmar que el punto final funciona correctamente, ejecute el siguiente código de inferencia de ejemplo en su SageMaker bloc de notas:

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