Aloje varios modelos de visión artificial de TensorFlow con puntos finales de varios modelos de Amazon SageMaker

Reeditado por Platón

seguidores: 0

Amazon SageMaker ayuda a los científicos y desarrolladores de datos a preparar, construir, entrenar e implementar modelos de aprendizaje automático (ML) de alta calidad rápidamente al reunir un amplio conjunto de capacidades diseñadas específicamente para ML. SageMaker acelera la innovación dentro de su organización al proporcionar herramientas diseñadas específicamente para cada paso del desarrollo de ML, incluido el etiquetado, la preparación de datos, la ingeniería de funciones, la detección de sesgos estadísticos, AutoML, capacitación, ajuste, alojamiento, explicabilidad, monitoreo y automatización del flujo de trabajo.

Las empresas están entrenando cada vez más modelos de aprendizaje automático basados en datos de usuarios individuales. Por ejemplo, un servicio para compartir imágenes diseñado para permitir el descubrimiento de información en Internet entrena modelos personalizados basados en las imágenes cargadas de cada usuario y el historial de navegación para personalizar las recomendaciones para ese usuario. La empresa también puede entrenar modelos personalizados basados en temas de búsqueda para recomendar imágenes por tema. La creación de modelos de AA personalizados para cada caso de uso conduce a una mayor precisión de inferencia, pero aumenta el costo de implementación y administración de modelos. Estos desafíos se vuelven más pronunciados cuando no se accede a todos los modelos al mismo ritmo, pero aún así deben estar disponibles en todo momento.

SageMaker puntos finales de varios modelos proporcionan una forma escalable y rentable de implementar una gran cantidad de modelos de aprendizaje automático en la nube. Los puntos finales de varios modelos de SageMaker le permiten implementar varios modelos de ML detrás de un único punto final y servirlos utilizando un único contenedor de servicio. Su aplicación simplemente necesita incluir una llamada a la API con el modelo de destino a este punto final para lograr una inferencia de baja latencia y alto rendimiento. En lugar de pagar por un punto final independiente para cada modelo, puede alojar muchos modelos por el precio de un único punto final. Para obtener más información sobre los puntos finales de varios modelos de SageMaker, consulte Ahorre en costos de inferencia mediante el uso de puntos finales multimodelo de Amazon SageMaker.

En esta publicación, demostramos cómo usar los puntos finales multimodelo de SageMaker para alojar dos modelos de visión por computadora con diferentes arquitecturas de modelos y conjuntos de datos para la clasificación de imágenes. En la práctica, puede implementar decenas de miles de modelos en puntos finales de varios modelos.

Resumen de la solución

Los extremos de varios modelos de SageMaker funcionan con varios marcos, como TensorFlow, PyTorch, MXNet y sklearn, y puede construya su propio contenedor con un servidor multimodelo. Los puntos finales de varios modelos también se admiten de forma nativa en los siguientes algoritmos integrados populares de SageMaker: XGBoost, Aprendiz lineal, Bosque de corte aleatorio (RCF) y K-Vecinos más cercanos (KNN). Puede utilizar directamente los contenedores proporcionados por SageMaker mientras utiliza estos algoritmos sin tener que crear su propio contenedor personalizado.

El siguiente diagrama es una ilustración simplificada de cómo puede alojar varios modelos (para esta publicación, seis) utilizando puntos finales de varios modelos de SageMaker. En la práctica, los puntos finales de varios modelos pueden acomodar de cientos a decenas de miles de modelos de ML detrás de un punto final. En nuestra arquitectura, si hospedamos más modelos usando artefactos de modelo almacenados en Servicio de almacenamiento simple de Amazon (Amazon S3), los puntos de enlace de varios modelos descargan dinámicamente algunos de los modelos menos utilizados para adaptarse a los modelos más nuevos.

En esta publicación, mostramos cómo alojar dos modelos de visión por computadora entrenados con el marco de TensorFlow detrás de un solo punto final de varios modelos de SageMaker. Usamos el Publicación de TensorFlow contenedor habilitado para puntos finales de varios modelos para alojar estos modelos. Para nuestro primer modelo, entrenamos una versión más pequeña de AlexNet CNN para clasificar imágenes de la CIFAR-10 conjunto de datos. Para el segundo modelo, usamos un VGG16 Modelo de CNN preentrenado en el ImagenNet conjunto de datos y ajustado en el Conjunto de datos de dígitos en lenguaje de señas para clasificar imágenes de símbolos de mano. También proporcionamos un completamente funcional cuaderno para demostrar todos los pasos.

Modelo 1: clasificación de imágenes CIFAR-10

CIFAR-10 es un conjunto de datos de referencia para la clasificación de imágenes en visión artificial y aprendizaje automático. Las imágenes CIFAR están coloreadas (tres canales) con una variación dramática en la apariencia de los objetos. Consta de imágenes en color de 32 × 32 en 10 clases, con 6,000 imágenes por clase. Contiene 50,000 imágenes de entrenamiento y 10,000 imágenes de prueba. La siguiente imagen muestra una muestra de las imágenes agrupadas por las etiquetas.

Para construir el clasificador de imágenes, usamos una versión simplificada del clásico AlexNet CNN. La red está compuesta por cinco capas convolucionales y agrupadas, y tres capas completamente conectadas. Nuestra arquitectura simplificada apila tres capas convolucionales y dos capas completamente conectadas (densas).

El primer paso es cargar el conjunto de datos en entrenar y probar objetos. El marco de trabajo de TensorFlow proporciona el conjunto de datos CIFAR para que lo carguemos usando el método load_data (). A continuación, cambiamos la escala de las imágenes de entrada dividiendo los valores de píxeles por 255: [0,255] ⇒ [0,1]. También necesitamos preparar las etiquetas usando codificación one-hot. Una codificación en caliente es un proceso mediante el cual las variables categóricas se convierten en una forma numérica. El siguiente fragmento de código muestra estos pasos en acción:

from tensorflow.keras.datasets import cifar10 # load dataset
(X_train, y_train), (X_test, y_test) = cifar10.load_data() # rescale input images
X_train = X_train.astype('float32')/255
X_test = X_test.astype('float32')/255 # one hot encode target labels
num_classes = len(np.unique(y_train))
y_train = utils.to_categorical(y_train, num_classes)
y_test = utils.to_categorical(y_test, num_classes)

Una vez que el conjunto de datos está preparado y listo para el entrenamiento, se guarda en Amazon S3 para que SageMaker lo utilice. La arquitectura del modelo y el código de entrenamiento para el clasificador de imágenes se ensamblan en un script de entrenamiento (tren_cifar.py). Para generar lotes de datos de imágenes de tensores para el proceso de entrenamiento, usamos ImageDataGenerator. Esto nos permite aplicar transformaciones de aumento de datos como cambios de rotación, ancho y altura a nuestros datos de entrenamiento.

En el siguiente paso, usamos la secuencia de comandos de entrenamiento para crear un estimador de TensorFlow con el SDK de SageMaker (consulte el siguiente código). Usamos el estimador para ajustar el modelo CNN en entradas CIFAR-10. Cuando se completa el entrenamiento, el modelo se guarda en Amazon S3.

from sagemaker.tensorflow import TensorFlow model_name = 'cifar-10' hyperparameters = {'epochs': 50} estimator_parameters = {'entry_point':'cifar_train.py', 'instance_type': 'ml.m5.2xlarge', 'instance_count': 2, 'model_dir': f'/opt/ml/model', 'role': role, 'hyperparameters': hyperparameters, 'output_path': f's3://{BUCKET}/{PREFIX}/cifar_10/out', 'base_job_name': f'mme-cv-{model_name}', 'framework_version': TF_FRAMEWORK_VERSION, 'py_version': 'py37', 'script_mode': True} estimator_1 = TensorFlow(**estimator_parameters) estimator_1.fit(inputs)

Más adelante, demostramos cómo alojar este modelo utilizando el punto final multimodelo de SageMaker junto con nuestro segundo modelo (el clasificador de dígitos del lenguaje de señas).

Modelo 2: Clasificación de dígitos en lenguaje de señas

Para nuestro segundo modelo, usamos el conjunto de datos de dígitos del lenguaje de señas. Este conjunto de datos distingue los dígitos del lenguaje de señas del 0 al 9. La siguiente imagen muestra una muestra del conjunto de datos.

El conjunto de datos contiene imágenes de 100 x 100 en color RGB y tiene 10 clases (dígitos del 0 al 9). El conjunto de entrenamiento contiene 1,712 imágenes, el conjunto de validación 300 y el conjunto de prueba 50.

Este conjunto de datos es muy pequeño. Entrenar una red desde cero en un conjunto de datos tan pequeño no logra buenos resultados. Para lograr una mayor precisión, utilizamos transferir aprendizaje. El aprendizaje por transferencia suele ser el enfoque a seguir al iniciar un proyecto de clasificación, especialmente cuando no tiene muchos datos de entrenamiento. Migra el conocimiento aprendido del conjunto de datos de origen al conjunto de datos de destino, para ahorrar tiempo de entrenamiento y costos computacionales.

Para entrenar este modelo, usamos un modelo CNN VGG16 previamente entrenado en el conjunto de datos de ImageNet y lo ajustamos para que funcione en nuestro conjunto de datos de dígitos en lenguaje de señas. Un modelo preentrenado es una red que se ha entrenado previamente en un gran conjunto de datos, normalmente en una tarea de clasificación de imágenes a gran escala. La arquitectura del modelo VGG16 que utilizamos tiene 13 capas convolucionales en total. Para el conjunto de datos de lenguaje de señas, debido a que su dominio es diferente del dominio de origen del conjunto de datos de ImageNet, solo ajustamos las últimas capas. El ajuste fino aquí se refiere a congelar algunas de las capas de red que se utilizan para la extracción de características y entrenar conjuntamente tanto las capas no congeladas como las capas de clasificador recién agregadas del modelo preentrenado.

El guión de entrenamiento (sign_language_train.py) encapsula la arquitectura del modelo y la lógica de entrenamiento para el clasificador de dígitos de la lengua de signos. Primero, cargamos los pesos preentrenados de la red VGG16 entrenada en el conjunto de datos ImageNet. A continuación, congelamos parte de la parte del extractor de características, y luego agregamos las nuevas capas de clasificador. Finalmente, compilamos la red y ejecutamos el proceso de entrenamiento para optimizar el modelo para el conjunto de datos más pequeño.

A continuación, usamos este script de entrenamiento para crear un estimador de TensorFlow con el SDK de SageMaker. Este estimador se utiliza para ajustar el clasificador de dígitos del lenguaje de señas en las entradas suministradas. Una vez finalizada la formación, el modelo se guarda en Amazon S3 para alojarlo en los puntos de enlace de varios modelos de SageMaker. Vea el siguiente código:

model_name = 'sign-language' hyperparameters = {'epochs': 50} estimator_parameters = {'entry_point':'sign_language_train.py', 'instance_type': 'ml.m5.2xlarge', 'instance_count': 2, 'hyperparameters': hyperparameters, 'model_dir': f'/opt/ml/model', 'role': role, 'output_path': f's3://{BUCKET}/{PREFIX}/sign_language/out', 'base_job_name': f'cv-{model_name}', 'framework_version': TF_FRAMEWORK_VERSION, 'py_version': 'py37', 'script_mode': True} estimator_2 = TensorFlow(**estimator_parameters) estimator_2.fit({'train': train_input, 'val': val_input})

Implementar un punto final de varios modelos

Los terminales de varios modelos de SageMaker proporcionan una solución escalable y rentable para implementar una gran cantidad de modelos. Utiliza un contenedor de servicio compartido que está habilitado para albergar varios modelos. Esto reduce los costos de alojamiento al mejorar la utilización de los puntos finales en comparación con el uso de puntos finales de un solo modelo. También reduce la sobrecarga de implementación porque SageMaker administra la carga de modelos en la memoria y los escala según los patrones de tráfico hacia ellos.

Para crear el punto final multimodelo, primero debemos copiar los modelos entrenados para los estimadores individuales (1 y 2) desde sus ubicaciones S3 guardadas a un prefijo S3 común que pueda ser utilizado por el punto final multimodelo:

tf_model_1 = estimator_1.model_data
output_1 = f's3://{BUCKET}/{PREFIX}/mme/cifar.tar.gz' tf_model_2 = estimator_2.model_data
output_2 = f's3://{BUCKET}/{PREFIX}/mme/sign-language.tar.gz' !aws s3 cp {tf_model_1} {output_1}
!aws s3 cp {tf_model_2} {output_2}

Una vez que los modelos se copian en la ubicación común designada por el prefijo S3, creamos un modelo de publicación con la clase TensorFlowModel del SDK de SageMaker. El modelo de publicación se crea para que uno de los modelos se aloje en el punto final de varios modelos. En este caso, utilizamos el primer modelo (el clasificador de imágenes CIFAR-10). A continuación, usamos la clase MultiDataModel del SDK de SageMaker para crear un modelo de datos de múltiples modelos utilizando el modelo de servicio para el modelo 1, que creamos en el paso anterior:

from sagemaker.tensorflow.serving import TensorFlowModel
from sagemaker.multidatamodel import MultiDataModel model_1 = TensorFlowModel(model_data=output_1, role=role, image_uri=IMAGE_URI) mme = MultiDataModel(name=f'mme-tensorflow-{current_time}', model_data_prefix=model_data_prefix, model=model_1, sagemaker_session=sagemaker_session)

Finalmente, implementamos MultiDataModel llamando al método deploy (), proporcionando los atributos necesarios para crear la infraestructura de alojamiento necesaria para respaldar el punto final de múltiples modelos:

predictor = mme.deploy(initial_instance_count=2, instance_type='ml.m5.2xlarge', endpoint_name=f'mme-tensorflow-{current_time}')

La llamada de implementación devuelve una instancia de predictor, que podemos usar para realizar llamadas de inferencia. Vemos esto en la siguiente sección.

Pruebe el punto final de varios modelos para realizar inferencias en tiempo real

Los puntos finales de varios modelos permiten compartir recursos de memoria entre sus modelos. Si el modelo al que se hace referencia ya está almacenado en caché, los puntos finales de varios modelos ejecutan la inferencia inmediatamente. Por otro lado, si el modelo solicitado en particular no se almacena en caché, SageMaker tiene que descargar el modelo, lo que aumenta la latencia para esa solicitud inicial. Sin embargo, esto toma solo una fracción del tiempo que tomaría lanzar una infraestructura (instancias) completamente nueva para alojar el modelo individualmente en SageMaker. Una vez que un modelo se almacena en caché en el punto final de varios modelos, las solicitudes posteriores se inician en tiempo real (a menos que se elimine el modelo). Como resultado, puede ejecutar muchos modelos desde una sola instancia, desacoplando efectivamente nuestra cantidad de modelos de nuestro costo de implementación. Esto facilita la administración de las implementaciones de ML a escala y reduce los costos de implementación de su modelo a través de un mayor uso del punto final y sus instancias informáticas subyacentes. Para obtener más información y una demostración de ahorros de costos de más del 90% para un ejemplo de 1,000 modelos, consulte Ahorre en costos de inferencia con los puntos de enlace multimodelo de Amazon SageMaker.

Los puntos finales de varios modelos también descargan los modelos no utilizados del contenedor cuando las instancias que respaldan el punto final alcanzan la capacidad de memoria y es necesario cargar más modelos en su contenedor. SageMaker elimina los artefactos de modelo no utilizados del volumen de almacenamiento de la instancia cuando el volumen alcanza su capacidad máxima y es necesario descargar nuevos modelos. La primera invocación a un modelo recién agregado tarda más porque el punto de enlace tarda más en descargar el modelo de Amazon S3 a la memoria del contenedor de las instancias que respaldan el punto de enlace de varios modelos. Los modelos que se descargan permanecen en el volumen de almacenamiento de la instancia y se pueden cargar en la memoria del contenedor más tarde sin que se descarguen nuevamente desde el depósito de S3.

Veamos cómo hacer una inferencia a partir del clasificador de imágenes CIFAR-10 (modelo-1) alojado en el punto final de múltiples modelos. Primero, cargamos una imagen de muestra de una de las clases —avión— y la preparamos para enviarla al punto final de múltiples modelos utilizando el predictor que creamos en el paso anterior.

Con este predictor, podemos llamar al método predict () junto con el parámetro initial_args, que especifica el nombre del modelo de destino a invocar. En este caso, el modelo de destino es cifar.tar.gz. El siguiente fragmento muestra este proceso en detalle:

img = load_img('./data/cifar_10/raw_images/airplane.png', target_size=(32, 32))
data = img_to_array(img)
data = data.astype('float32')
data = data / 255.0
data = data.reshape(1, 32, 32, 3)
payload = {'instances': data}
y_pred = predictor.predict(data=payload, initial_args={'TargetModel': 'cifar.tar.gz'})
predicted_label = CIFAR10_LABELS[np.argmax(y_pred)]
print(f'Predicted Label: [{predicted_label}]')

La ejecución del código anterior devuelve el resultado de la predicción como la etiqueta avión, que nuestro modelo servido interpreta correctamente:

Predicted Label: [airplane]

A continuación, veamos cómo cargar dinámicamente el clasificador de dígitos del lenguaje de señas (modelo-2) en un punto final de varios modelos invocando el punto final con sign-language.tar.gz como modelo de destino.

Usamos la siguiente imagen de muestra del dígito 0 del signo de la mano.

El siguiente fragmento muestra cómo invocar el punto final de varios modelos con la imagen de muestra para obtener la respuesta correcta:

test_path = './data/sign_language/test'
img = mpimg.imread(f'{test_path}/0/IMG_4159.JPG') def path_to_tensor(img_path): # loads RGB image as PIL.Image.Image type img = image.load_img(img_path, target_size=(224, 224)) # convert PIL.Image.Image type to 3D tensor with shape (224, 224, 3) x = image.img_to_array(img) # convert 3D tensor to 4D tensor with shape (1, 224, 224, 3) and return 4D tensor return np.expand_dims(x, axis=0) data = path_to_tensor(f'{test_path}/0/IMG_4159.JPG')
payload = {'instances': data}
y_pred = predictor.predict(data=payload, initial_args={'TargetModel': 'sign-language.tar.gz'})predicted_label = np.argmax(y_pred)
print(f'Predicted Label: [{predicted_label}]')

El siguiente código es nuestra respuesta, con la etiqueta 0:

Predicted Label: [0]

Conclusión

En esta publicación, demostramos la función SageMaker puntos finales de varios modelos para optimizar los costos de inferencia. Los puntos finales de varios modelos son útiles cuando se trabaja con cientos o decenas de miles de modelos y cuando no es necesario implementar cada modelo como un punto final individual. Los modelos se cargan y descargan dinámicamente, según el uso y la cantidad de memoria disponible en el endpoint.

En esta publicación, se discutió cómo alojar múltiples modelos de visión por computadora entrenados con el marco TensorFlow en un punto final de múltiples modelos de SageMaker. Los modelos de clasificación de imágenes fueron de diferentes arquitecturas de modelos y se entrenaron en diferentes conjuntos de datos. La cuaderno incluido con la publicación proporciona instrucciones detalladas sobre la formación y el alojamiento de los modelos.

Pruebe los puntos finales de varios modelos de SageMaker para su caso de uso y deje sus comentarios en los comentarios.

Acerca de los autores

Arunprasath Shankar es un arquitecto de soluciones especializado en inteligencia artificial y aprendizaje automático (AI / ML) en AWS, que ayuda a los clientes globales a escalar sus soluciones de inteligencia artificial de manera efectiva y eficiente en la nube. En su tiempo libre, a Arun le gusta ver películas de ciencia ficción y escuchar música clásica.

marca roy es un arquitecto principal de aprendizaje automático para AWS, que ayuda a los clientes de AWS a diseñar y crear soluciones de IA / ML. El trabajo de Mark cubre una amplia gama de casos de uso de aprendizaje automático, con un interés principal en la visión por computadora, el aprendizaje profundo y la ampliación del aprendizaje automático en toda la empresa. Ha ayudado a empresas en muchas industrias, incluidas las de seguros, servicios financieros, medios y entretenimiento, atención médica, servicios públicos y fabricación. Mark posee seis certificaciones de AWS, incluida la Certificación de especialidad ML. Antes de unirse a AWS, Mark fue arquitecto, desarrollador y líder tecnológico durante más de 25 años, incluidos 19 años en servicios financieros.