Implemente modelos de Amazon SageMaker Autopilot en puntos finales de inferencia sin servidor

Piloto automático Amazon SageMaker crea, entrena y ajusta automáticamente los mejores modelos de aprendizaje automático (ML) en función de sus datos, al tiempo que le permite mantener el control y la visibilidad totales. Autopilot también puede implementar modelos entrenados en puntos finales de inferencia en tiempo real automáticamente.

Si tiene cargas de trabajo con patrones de tráfico irregulares o impredecibles que pueden tolerar arranques en frío, sería más rentable implementar el modelo en un extremo de inferencia sin servidor.

Inferencia sin servidor de Amazon SageMaker es una opción de inferencia especialmente diseñada, ideal para cargas de trabajo con patrones de tráfico impredecibles y que pueden tolerar arranques en frío. A diferencia de un punto final de inferencia en tiempo real, que está respaldado por una instancia informática de ejecución prolongada, los puntos finales sin servidor aprovisionan recursos a pedido con escalado automático integrado. Los puntos finales sin servidor escalan automáticamente según la cantidad de solicitudes entrantes y reducen los recursos a cero cuando no hay solicitudes entrantes, lo que lo ayuda a minimizar sus costos.

En esta publicación, mostramos cómo implementar modelos entrenados de Autopilot en puntos finales de inferencia sin servidor usando el Bibliotecas Boto3 para Amazon SageMaker.

Modos de entrenamiento de piloto automático

Antes de crear un experimento de Autopilot, puede dejar que Autopilot seleccione el modo de entrenamiento automáticamente o puede seleccionar el modo de entrenamiento manualmente.

Autopilot actualmente admite tres modos de entrenamiento:

• Auto – Según el tamaño del conjunto de datos, Autopilot elige automáticamente el modo de ensamblaje o HPO. Para conjuntos de datos de más de 100 MB, Autopilot elige HPO; de lo contrario, elige el conjunto.
• Ensamblaje – El piloto automático utiliza el AutoGluón técnica de ensamblaje utilizando el apilamiento de modelos y produce un modelo predictivo óptimo.
• Optimización de hiperparámetros (HPO) – El piloto automático encuentra la mejor versión de un modelo ajustando los hiperparámetros mediante la optimización bayesiana o la optimización de fidelidad múltiple mientras ejecuta trabajos de entrenamiento en su conjunto de datos. El modo HPO selecciona los algoritmos más relevantes para su conjunto de datos y selecciona el mejor rango de hiperparámetros para ajustar sus modelos.

Para obtener más información sobre los modos de entrenamiento del piloto automático, consulte Modos de entrenamiento.

Resumen de la solución

En esta publicación, usamos el Mercadotecnia Bancaria UCI conjunto de datos para predecir si un cliente suscribirá un depósito a plazo ofrecido por el banco. Este es un tipo de problema de clasificación binaria.

Lanzamos dos trabajos de Autopilot usando el Bibliotecas de Boto3 para SageMaker. El primer trabajo utiliza el ensamblaje como modo de entrenamiento elegido. Luego implementamos el modelo de conjunto único generado en un punto final sin servidor y enviamos solicitudes de inferencia a este punto final alojado.

El segundo trabajo usa el modo de entrenamiento HPO. Para los tipos de problemas de clasificación, Autopilot genera tres contenedores de inferencia. Extraemos estos tres contenedores de inferencia y los implementamos en puntos finales sin servidor separados. Luego, enviamos solicitudes de inferencia a estos puntos finales alojados.

Para obtener más información sobre los tipos de problemas de regresión y clasificación, consulte Definiciones de contenedores de inferencia para tipos de problemas de regresión y clasificación.

También podemos lanzar trabajos de Autopilot desde el Estudio Amazon SageMaker interfaz de usuario Si inicia trabajos desde la interfaz de usuario, asegúrese de apagar el Implementación automática opción en el Implementación y configuración avanzada sección. De lo contrario, Autopilot implementará el mejor candidato en un punto final en tiempo real.

Requisitos previos

Asegúrese de tener instalada la última versión de Boto3 y los paquetes SageMaker Python:

pip install -U boto3 sagemaker

Necesitamos la versión del paquete de SageMaker >= 2.110.0 y versión Boto3 >= boto3-1.24.84.

Inicie un trabajo de Autopilot con el modo de ensamblaje

Para iniciar un trabajo de Autopilot usando las bibliotecas de SageMaker Boto3, usamos el crear_auto_ml_trabajo API. Luego pasamos AutoMLJobConfig, InputDataConfigy AutoMLJobObjective como entradas a la create_auto_ml_job. Ver el siguiente código:

bucket = session.default_bucket()
role = sagemaker.get_execution_role()
prefix = "autopilot/bankadditional"
sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

timestamp_suffix = strftime('%d%b%Y-%H%M%S', gmtime())
automl_job_name = f"uci-bank-marketing-{timestamp_suffix}"
max_job_runtime_seconds = 3600
max_runtime_per_job_seconds = 1200
target_column = "y"
problem_type="BinaryClassification"
objective_metric = "F1"
training_mode = "ENSEMBLING"

automl_job_config = {
    'CompletionCriteria': {
      'MaxRuntimePerTrainingJobInSeconds': max_runtime_per_job_seconds,
      'MaxAutoMLJobRuntimeInSeconds': max_job_runtime_seconds
    },    
    "Mode" : training_mode
}

automl_job_objective= { "MetricName": objective_metric }

input_data_config = [
    {
      'DataSource': {
        'S3DataSource': {
          'S3DataType': 'S3Prefix',
          'S3Uri': f's3://{bucket}/{prefix}/raw/bank-additional-full.csv'
        }
      },
      'TargetAttributeName': target_column
    }
  ]

output_data_config = {
	    'S3OutputPath': f's3://{bucket}/{prefix}/output'
	}


sm_client.create_auto_ml_job(
				AutoMLJobName=auto_ml_job_name,
				InputDataConfig=input_data_config,
				OutputDataConfig=output_data_config,
				AutoMLJobConfig=automl_job_config,
				ProblemType=problem_type,
				AutoMLJobObjective=automl_job_objective,
				RoleArn=role)

El piloto automático devuelve el BestCandidate objeto modelo que tiene la InferenceContainers necesarios para implementar los modelos en puntos finales de inferencia. Para obtener el BestCandidate para el trabajo anterior, usamos el describe_automl_job función:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_container = job_response['BestCandidate']['InferenceContainers'][0]
print(inference_container)

Implementar el modelo entrenado

Ahora implementamos el contenedor de inferencia anterior en un punto final sin servidor. El primer paso es crear un modelo desde el contenedor de inferencia, luego crear una configuración de punto final en la que especificamos el MemorySizeInMB y MaxConcurrency valores para el extremo sin servidor junto con el nombre del modelo. Finalmente, creamos un punto final con la configuración de punto final creada anteriormente.

Recomendamos elegir su tamaño de la memoria del punto final Según el tamaño de tu modelo. El tamaño de la memoria debe ser al menos tan grande como el tamaño de su modelo. Su terminal sin servidor tiene un tamaño mínimo de RAM de 1024 MB (1 GB) y el tamaño máximo de RAM que puede elegir es de 6144 MB (6 GB).

Los tamaños de memoria que puede elegir son 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB o 6144 MB.

Para ayudar a determinar si un punto final sin servidor es la opción de implementación correcta desde una perspectiva de costo y rendimiento, le recomendamos que consulte la Kit de herramientas de evaluación comparativa de inferencia sin servidor de SageMaker, que prueba diferentes configuraciones de puntos finales y compara la más óptima con una instancia de alojamiento en tiempo real comparable.

Tenga en cuenta que los puntos finales sin servidor solo aceptan SingleModel para contenedores de inferencia. El piloto automático en el modo de ensamblaje genera un solo modelo, por lo que podemos implementar este contenedor de modelo tal como está en el punto final. Ver el siguiente código:

# Create Model
	model_response = sm_client.create_model(
				ModelName=model_name,
				ExecutionRoleArn=role,
				Containers=[inference_container]
	)

# Create Endpoint Config
	epc_response = sm_client.create_endpoint_config(
		EndpointConfigName = endpoint_config_name,
		ProductionVariants=[
			{
				"ModelName": model_name,
				"VariantName": "AllTraffic",
				"ServerlessConfig": {
					"MemorySizeInMB": memory,
					"MaxConcurrency": max_concurrency
				}
			}
		]
	)

# Create Endpoint
	ep_response = sm_client.create_endpoint(
		EndpointName=endpoint_name,
		EndpointConfigName=endpoint_config_name
	)

Cuando el punto final de inferencia sin servidor es InService, podemos probar el punto final enviando una solicitud de inferencia y observando las predicciones. El siguiente diagrama ilustra la arquitectura de esta configuración.

Tenga en cuenta que podemos enviar datos sin procesar como carga útil al punto final. El modelo de conjunto generado por Autopilot incorpora automáticamente todos los pasos requeridos de transformación de características y transformación de etiquetas inversas, junto con el modelo de algoritmo y los paquetes, en un solo modelo.

Enviar solicitud de inferencia al modelo entrenado

Use el siguiente código para enviar inferencias sobre su modelo entrenado usando el modo de ensamblaje:

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


payload = "34,blue-collar,married,basic.4y,no,no,no,telephone,may,tue,800,4,999,0,nonexistent,1.1,93.994,-36.4,4.857,5191.0"

predictor = Predictor(
        endpoint_name=endpoint,
        sagmaker_session=session,
        serializer=CSVSerializer(),
    )

prediction = predictor.predict(payload).decode(‘utf-8’)
print(prediction)

Iniciar un trabajo de piloto automático con el modo HPO

En el modo HPO, para CompletionCriteriaademás MaxRuntimePerTrainingJobInSeconds y MaxAutoMLJobRuntimeInSeconds, También podríamos especificar el MaxCandidates para limitar el número de candidatos que generará un trabajo de Autopilot. Tenga en cuenta que estos son parámetros opcionales y solo se configuran para limitar el tiempo de ejecución del trabajo para la demostración. Ver el siguiente código:

training_mode = "HYPERPARAMETER_TUNING"

automl_job_config["Mode"] = training_mode
automl_job_config["CompletionCriteria"]["MaxCandidates"] = 15
hpo_automl_job_name =  f"{model_prefix}-HPO-{timestamp_suffix}"

response = sm_client.create_auto_ml_job(
					  AutoMLJobName=hpo_automl_job_name,
					  InputDataConfig=input_data_config,
					  OutputDataConfig=output_data_config,
					  AutoMLJobConfig=automl_job_config,
					  ProblemType=problem_type,
					  AutoMLJobObjective=automl_job_objective,
					  RoleArn=role,
					  Tags=tags_config
				)

Para obtener el BestCandidate para el trabajo anterior, podemos volver a utilizar el describe_automl_job función:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_containers = job_response['BestCandidate']['InferenceContainers']
print(inference_containers)

Implementar el modelo entrenado

El piloto automático en modo HPO para el tipo de problema de clasificación genera tres contenedores de inferencia.

El primer contenedor maneja los pasos de transformación de características. A continuación, el contenedor del algoritmo genera el predicted_label con la mayor probabilidad. Finalmente, el contenedor de inferencia de posprocesamiento realiza una transformación inversa en la etiqueta predicha y la asigna a la etiqueta original. Para obtener más información, consulte Definiciones de contenedores de inferencia para tipos de problemas de regresión y clasificación.

Extraemos estos tres contenedores de inferencia y los implementamos en puntos finales independientes sin servidor. Para la inferencia, invocamos los puntos finales en secuencia enviando la carga útil primero al contenedor de transformación de características, luego pasando la salida de este contenedor al contenedor del algoritmo y finalmente pasando la salida del contenedor de inferencia anterior al contenedor de posprocesamiento. que genera la etiqueta predicha.

El siguiente diagrama ilustra la arquitectura de esta configuración.

Extraemos los tres contenedores de inferencia del BestCandidate con el siguiente código:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
inference_containers = job_response['BestCandidate']['InferenceContainers']

models = list()
endpoint_configs = list()
endpoints = list()

# For brevity, we've encapsulated create_model, create endpoint_config and create_endpoint as helper functions
for idx, container in enumerate(inference_containers):
    (status, model_arn) = create_autopilot_model(
								    sm_client,
								    automl_job_name,
            						role,
								    container,
								    idx)
    model_name = model_arn.split('/')[1]
    models.append(model_name)

    endpoint_config_name = f"epc-{model_name}"
    endpoint_name = f"ep-{model_name}"
    (status, epc_arn) = create_serverless_endpoint_config(
								    sm_client,
								    endpoint_config_name,
								    model_name,
            						memory=2048,
								    max_concurrency=10)
	endpoint_configs.append(endpoint_config_name)

	response = create_serverless_endpoint(
								    sm_client,
								    endpoint_name,
								    endpoint_config_name)
	endpoints.append(endpoint_name)

Enviar solicitud de inferencia al modelo entrenado

Para la inferencia, enviamos la carga útil en secuencia: primero al contenedor de transformación de características, luego al contenedor de modelo y finalmente al contenedor de transformación de etiqueta inversa.

Ver el siguiente código:

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

payload = "51,technician,married,professional.course,no,yes,no,cellular,apr,thu,687,1,0,1,success,-1.8,93.075,-47.1,1.365,5099.1"


for _, endpoint in enumerate(endpoints):
    try:
        print(f"payload: {payload}")
        predictor = Predictor(
            endpoint_name=endpoint,
            sagemaker_session=session,
            serializer=CSVSerializer(),
        )
        prediction = predictor.predict(payload)
        payload=prediction
    except Exception as e:
        print(f"Error invoking Endpoint; {endpoint} n {e}")
        break

La implementación completa de este ejemplo está disponible en el siguiente jupyter cuaderno.

Limpiar

Para limpiar los recursos, puede eliminar los puntos finales sin servidor creados, las configuraciones de puntos finales y los modelos:

sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

for _, endpoint in enumerate(endpoints):
    try:
        sm_client.delete_endpoint(EndpointName=endpoint)
    except Exception as e:
        print(f"Exception:n{e}")
        continue
        
for _, endpoint_config in enumerate(endpoint_configs):
    try:
        sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

for _, autopilot_model in enumerate(models):
    try:
        sm_client.delete_model(ModelName=autopilot_model)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

Conclusión

En esta publicación, mostramos cómo podemos implementar modelos generados por Autopilot tanto en modo conjunto como HPO en puntos finales de inferencia sin servidor. Esta solución puede acelerar su capacidad de usar y aprovechar los servicios de ML rentables y totalmente administrados como Autopilot para generar modelos rápidamente a partir de datos sin procesar y luego implementarlos en puntos finales de inferencia sin servidor totalmente administrados con escalado automático incorporado para reducir costos. .

Lo alentamos a que pruebe esta solución con un conjunto de datos relevante para los KPI de su negocio. Puede consultar la solución implementada en un cuaderno Jupyter en el Repositorio GitHub.

Referencias adicionales

Sobre la autora

Praveen chamarthi es un especialista sénior en inteligencia artificial y aprendizaje automático de Amazon Web Services. Le apasiona la IA/ML y todo lo relacionado con AWS. Ayuda a los clientes de América a escalar, innovar y operar cargas de trabajo de ML de manera eficiente en AWS. En su tiempo libre, a Praveen le encanta leer y disfruta de las películas de ciencia ficción.