Prueba de carga simplificada con el recomendador de inferencia de SageMaker

Pruebe TensorFlow ResNet50 en terminales en tiempo real de SageMaker

En el pasado, escribí mucho sobre la importancia de realizar pruebas de carga en los modelos de aprendizaje automático antes de implementarlos en producción. Cuando se trata de casos de uso específicos de inferencia en tiempo real, es esencial asegurarse de que su solución cumpla con su latencia y rendimiento objetivo. También exploramos cómo podemos usar la biblioteca de Python, Locust, para definir scripts que puedan simular nuestros patrones de tráfico esperados.

Si bien Locust es una herramienta increíblemente poderosa, puede ser difícil de configurar y también requiere muchas iteraciones en los diferentes hiperparámetros y hardware que puede estar probando para identificar la configuración adecuada para la producción. Para SageMaker Real-Time Inference, una herramienta clave para echar un vistazo es SageMaker Inference Recommender. En lugar de tener que ejecutar repetidamente un script de Locust en diferentes configuraciones, básicamente puede pasar una matriz de tipos de instancias EC2 para probar su punto final, así como hiperparámetros para su contenedor de modelo específico para implementaciones más avanzadas. En el blog de hoy, veremos cómo podemos configurar esta función y cómo podemos simplificar las pruebas de carga de los terminales de SageMaker Real-Time.

NOTA: este artículo asumirá conocimientos básicos de AWS, SageMaker y Python. Para comprender qué es la inferencia en tiempo real de SageMaker, consulte el siguiente blog de inicio.

7 excelentes aplicaciones web de IA que puedes probar ahora mismo

Configuración y prueba local de inferencia

Para el desarrollo, puede utilizar una instancia de SageMaker Classic Notebook o un SageMaker Studio Kernel. Para nuestro entorno, utilizamos un Kernel TensorFlow 2.0 con Python3 en una instancia base ml.t3.medium.

El modelo que utilizaremos hoy es un TensorFlow ResNet50 preentrenado para la clasificación de imágenes. Primero podemos recuperar este modelo del concentrador de modelos de TensorFlow y extraerlo en nuestro cuaderno.

import os
import tensorflow as tf
from tensorflow.keras.applications import resnet50
from tensorflow.keras import backend
import numpy as np
from tensorflow.keras.preprocessing import image

Antes de comenzar las pruebas en SageMaker, queremos probar este modelo localmente para que podamos tener una idea del tipo de formato de entrada que necesitamos configurar para nuestro punto final. Para nuestro punto de datos de muestra, usaremos una foto de mi perro Milo cuando era un cachorro (ahora es un gigante).

#model = tf.keras.applications.ResNet50()
tf.keras.backend.set_learning_phase(0)
model = resnet50.ResNet50()
# Load the image file, resizing it to 224x224 pixels (required by this model)
img = image.load_img("dog.jpg", target_size=(224, 224))
# Convert the image to a numpy array
x = image.img_to_array(img)
# Add a forth dimension since Keras expects a list of images
x = np.expand_dims(x, axis=0)
También te puede interesar6 increíbles extensiones de Chrome ChatGPT para mejores solicitudes y respuestas de IA en los navegadores
# Scale the input image to the range used in the trained network
x = resnet50.preprocess_input(x)
print("predicting model")
predictions = model.predict(x)
predicted_classes = resnet50.decode_predictions(predictions, top=9)
print(predicted_classes)

Ahora hemos verificado el formato en el que nuestro modelo espera la inferencia para que podamos concentrarnos en configurarlo para SageMaker.

Preparar modelo y carga útil

SageMaker Inference Recommender espera dos entradas obligatorias: los datos del modelo y una carga útil de muestra. Para ambos, lo espera en formato tarball, por lo que tomamos nuestros artefactos y los comprimimos en un formato que el servicio entienda.

Aprendizaje multitarea (MTL)

Para nuestro modelo, podemos tomar el modelo que ya cargamos anteriormente en el cuaderno o instanciar una nueva versión. Descargamos los artefactos del modelo en un directorio local con los metadatos necesarios para TensorFlow Serving.

export_dir = "00001"
tf.keras.backend.set_learning_phase(0)
model = tf.keras.applications.ResNet50()
if not os.path.exists(export_dir):
os.makedirs(export_dir)
print("Directory ", export_dir, " Created ")
else:
print("Directory ", export_dir, " already exists")
# Save to SavedModel
model.save(export_dir, save_format="tf", include_optimizer=False)

Luego podemos tar esto en un model.tar.gz y subirlo a un depósito S3 al que podemos señalar el Recomendador de inferencia.

!tar -cvpzf model.tar.gz ./00001
#upload data to S3
model_url = sagemaker_session.upload_data(
path="model.tar.gz", key_prefix="resnet-model-data"
)
También te puede interesarEl auge de las aplicaciones de PNL impulsadas por API: ¿Ciclo exagerado o una nueva industria disruptiva?

Luego tomamos nuestra imagen de muestra y la convertimos en un JSON para nuestro modelo y lo guardamos en un tarball de manera similar a como lo hicimos para los artefactos del modelo.

import json
payload = json.dumps(x.tolist())
payload_archive_name = "payload.tar.gz"
with open("payload.json", "w") as outfile:
outfile.write(payload)
#create payload tarball
!tar -cvzf {payload_archive_name} payload.json
#upload sample payload to S3
sample_payload_url = sagemaker_session.upload_data(
path=payload_archive_name, key_prefix="resnet-payload"
)

Ahora que tenemos nuestras entradas configuradas, podemos pasar a la parte de SageMaker del proyecto.

Cree un modelo y seguimiento de SageMaker con el registro de modelos

SageMaker tiene algunos objetos específicos específicos de su servicio, uno importante para nosotros en este caso es la entidad SageMaker Model. Esta entidad modelo consta de dos factores centrales: datos del modelo y contenedor/imagen. Los datos del modelo pueden ser sus artefactos de modelo entrenados o previamente entrenados que proporciona en un S3 Bucket. El contenedor es esencialmente el marco de su modelo. En este caso, podemos recuperar la imagen administrada de SageMaker TensorFlow, pero también puede crear y enviar su propio contenedor si AWS Deep Learning Containers no lo admite. Aquí definimos este objeto de modelo de SageMaker, utilizando el SDK de Python de SageMaker.

import sagemaker
from sagemaker.model import Model
from sagemaker import image_uris
model = Model(
model_data=model_url,
role=role,
image_uri = sagemaker.image_uris.retrieve(framework="tensorflow", region=region, version="2.1", py_version="py3", 
image_scope='inference', instance_type="ml.m5.xlarge"),
sagemaker_session=sagemaker_session
)

Un paso opcional que puede utilizar es registrar su modelo con SageMaker Model Registry. El seguimiento de cientos de modelos puede ser un proceso difícil y con Model Registry puede simplificar esencialmente el control de versiones y el linaje del modelo para que tenga todas las entidades del modelo en un espacio central. Podemos registrar un modelo con la siguiente llamada a la API.

model_package = model.register(
content_types=["application/json"],
response_types=["application/json"],
model_package_group_name=model_package_group_name,
image_uri=model.image_uri,
approval_status="Approved",
framework="TENSORFLOW"
)

También podemos ver el paquete del modelo que acabamos de crear en SageMaker Studio Console.

En un caso de uso del mundo real, puede tener varios modelos dentro de un paquete de modelo único y puede aprobar el que elija implementar en producción.

Ahora que tenemos nuestro objeto Modelo preparado, podemos ejecutar un trabajo de recomendación de inferencia en esta entidad.

Trabajo de recomendación de inferencia

Hay dos tipos de trabajos de recomendación de inferencia: predeterminados y avanzados. Con un trabajo predeterminado, podemos simplemente pasar nuestra carga útil de muestra junto con una matriz de instancias EC2 con las que desea probar su modelo. Debajo del capó, Inference Recommender probará su modelo contra todas estas instancias y rastreará el rendimiento y la latencia para usted. Podemos utilizar la llamada a la API right_size para iniciar un trabajo de recomendación de inferencia.

model_package.right_size(
sample_payload_url=sample_payload_url,
supported_content_types=["application/json"],
supported_instance_types=["ml.c5.xlarge", "ml.c5.9xlarge", "ml.c5.18xlarge", "ml.m5d.24xlarge"],
framework="TENSORFLOW",
)

Este trabajo tardará aproximadamente entre 35 y 40 minutos en completarse, ya que iterará a través de los diferentes tipos de instancias que haya proporcionado. Luego podemos ver estos resultados en la interfaz de usuario de SageMaker Studio.

Aquí puede alternar el costo, la latencia y el rendimiento en niveles de importancia y obtener la configuración de hardware óptima. También puede crear su punto final directamente desde la consola si está satisfecho con el rendimiento que muestran las pruebas.

Por último, si desea probar diferentes hiperparámetros para su contenedor, esto también está disponible a través del trabajo de recomendación de inferencia avanzada. Aquí puede especificar hiperparámetros que se pueden ajustar para su modelo de contenedor específico.

from sagemaker.parameter import CategoricalParameter 
from sagemaker.inference_recommender.inference_recommender_mixin import (  
Phase,  
ModelLatencyThreshold 
) 
hyperparameter_ranges = [ 
{ 
"instance_types": CategoricalParameter(["ml.m5.xlarge", "ml.g4dn.xlarge"]), 
'OMP_NUM_THREADS': CategoricalParameter(['1', '2', '3']), 
} 
] 

Junto con esto, también puede configurar los patrones de tráfico para su prueba de carga. Por ejemplo, si desea aumentar la cantidad de usuarios en diferentes intervalos, puede configurar este comportamiento.

phases = [ 
Phase(duration_in_seconds=120, initial_number_of_users=2, spawn_rate=2), 
Phase(duration_in_seconds=120, initial_number_of_users=6, spawn_rate=2) 
]

También puede establecer umbrales, por ejemplo, si tiene un requisito de latencia estricto de 200 ms, esto se puede establecer como un parámetro de detención si su configuración no logra estos resultados.

model_latency_thresholds = [ 
ModelLatencyThreshold(percentile="P95", value_in_milliseconds=300) 
]

Luego puede iniciar y ver los resultados del trabajo avanzado de manera similar al trabajo predeterminado.

model_package.right_size( 
sample_payload_url=sample_payload_url, 
supported_content_types=["application/json"], 
framework="TENSORFLOW", 
job_duration_in_seconds=3600, 
hyperparameter_ranges=hyperparameter_ranges, 
phases=phases, # TrafficPattern 
max_invocations=100, # StoppingConditions 
model_latency_thresholds=model_latency_thresholds
)

Recursos adicionales y conclusión

Puede encontrar el código para este ejemplo y más en el enlace de arriba. SageMaker Inference Recommender es una poderosa herramienta que puede automatizar la parte difícil de la configuración de las pruebas de carga. Sin embargo, es importante tener en cuenta que, por el momento, no hay soporte para opciones de alojamiento avanzadas, como puntos finales de múltiples modelos y múltiples contenedores, por lo que para esos casos de uso será necesario utilizar un marco de trabajo de terceros como Locust. Como siempre, cualquier comentario es apreciado y no dude en comunicarse con cualquier pregunta o comentario, ¡gracias por leer!