Ejecute cargas de trabajo de inferencia de aprendizaje automático en instancias basadas en Graviton de AWS con Amazon SageMaker

Hoy estamos lanzando Amazon SageMaker inferencia sobre Gravitón de AWS para permitirle aprovechar los beneficios de precio, rendimiento y eficiencia que provienen de los chips Graviton.

Las instancias basadas en Graviton están disponibles para la inferencia de modelos en SageMaker. Esta publicación lo ayuda a migrar e implementar una carga de trabajo de inferencia de aprendizaje automático (ML) de x86 a instancias basadas en Graviton en SageMaker. Proporcionamos una guía paso a paso para implementar su modelo entrenado de SageMaker en instancias basadas en Graviton, cubrimos las mejores prácticas al trabajar con Graviton, discutimos los beneficios de precio-rendimiento y demostramos cómo implementar un modelo de TensorFlow en una instancia de SageMaker Graviton.

Breve descripción de Graviton

AWS Graviton es una familia de procesadores diseñados por AWS que brindan la mejor relación precio-rendimiento y son más eficientes energéticamente que sus contrapartes x86. Los procesadores AWS Graviton 3 son los últimos de la familia de procesadores Graviton y están optimizados para cargas de trabajo de aprendizaje automático, incluida la compatibilidad con bfloat16 y el doble del ancho de banda de datos múltiples de instrucción única (SIMD). Cuando se combinan estas dos funciones, Graviton 3 puede ofrecer un rendimiento hasta tres veces mejor que las instancias de Graviton 2. Graviton 3 también utiliza hasta un 60 % menos de energía para obtener el mismo rendimiento que sus equivalentes Nube informática elástica de Amazon (Amazon EC2) instancias. Esta es una gran característica si desea reducir su huella de carbono y lograr sus objetivos de sostenibilidad.

Resumen de la solución

Para implementar sus modelos en instancias de Graviton, puede usar Contenedores de aprendizaje profundo de AWS or trae tus propios contenedores compatible con la arquitectura Arm v8.2.

La migración (o nueva implementación) de sus modelos de instancias con tecnología x86 a instancias de Graviton es simple porque AWS proporciona contenedores para alojar modelos con PyTorch, TensorFlow, Scikit-learn y XGBoost, y los modelos son independientes de la arquitectura. Sin embargo, si está dispuesto a traer sus propias bibliotecas, también puede hacerlo, solo asegúrese de que su contenedor esté construido con un entorno compatible con la arquitectura Arm64. Para más información, ver Construyendo su propio contenedor de algoritmos.

Debe completar tres pasos para implementar su modelo:

1. Cree un modelo de SageMaker: este contendrá, entre otros parámetros, la información sobre la ubicación del archivo del modelo, el contenedor que se usará para la implementación y la ubicación del script de inferencia. (Si ya tiene un modelo existente implementado en una instancia de inferencia basada en x86, puede omitir este paso).
2. Cree una configuración de punto final: contendrá información sobre el tipo de instancia que desea para el punto final (por ejemplo, ml.c7g.xlarge para Graviton3), el nombre del modelo que creó en el paso 1 y la cantidad de instancias por punto final
3. Inicie el punto final con la configuración del punto final creada en el paso 2.

Requisitos previos

Antes de comenzar, tenga en cuenta los siguientes requisitos previos:

1. Complete los requisitos previos que se enumeran en Requisitos previos.
2. Su modelo debe ser un modelo basado en PyTorch, TensorFlow, XGBoost o Scikit-learn. La siguiente tabla resume las versiones admitidas actualmente a partir de este escrito. Para obtener las últimas actualizaciones, consulte Contenedores de SageMaker Framework (solo compatibilidad con SM).
   

   .	Python	TensorFlow	PyTorch	Scikit-learn	XGBoost
   Versiones compatibles	3.8	2.9.1	1.12.1	1.0 - 1	1.3-1 a 1.5-1

3. El script de inferencia se almacena en Servicio de almacenamiento simple de Amazon (Amazon S3).

En las siguientes secciones, lo guiaremos a través de los pasos de implementación.

Crear un modelo de SageMaker

Si ya tiene un modelo existente implementado en una instancia de inferencia basada en x86, puede omitir este paso. De lo contrario, complete los siguientes pasos para crear un modelo de SageMaker:

1. Busque el modelo que almacenó en un depósito S3. Copie la URI.
   Usará el URI del modelo más adelante en el MODEL_S3_LOCATION.
2. Identifique la versión del marco y la versión de Python que se usó durante el entrenamiento del modelo.
   Debe seleccionar un contenedor de la lista de contenedores de aprendizaje profundo de AWS disponibles según su marco y versión de Python. Para obtener más información, consulte Presentación de imágenes de contenedores de varias arquitecturas para Amazon ECR.
3. Ubique el URI del script Python de inferencia en el depósito de S3 (el nombre de archivo común es inference.py).
   El URI del script de inferencia es necesario en el INFERENCE_SCRIPT_S3_LOCATION.
4. Con estas variables, puede llamar a la API de SageMaker con el siguiente comando:

   client = boto3.client("sagemaker")
   
   client.create_model(
       ModelName="Your model name",
       PrimaryContainer={
           "Image": ,
           "ModelDataUrl": ,
           "Environment": {
           "SAGEMAKER_PROGRAM": "inference.py",
           "SAGEMAKER_SUBMIT_DIRECTORY": ,
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": 
           }
       },
       ExecutionRoleArn= 
   )

También puede crear imágenes de múltiples arquitecturas y usar la misma imagen pero con diferentes etiquetas. Puede indicar en qué arquitectura se implementará su instancia. Para obtener más información, consulte Presentación de imágenes de contenedores de varias arquitecturas para Amazon ECR.

Crear una configuración de punto final

Después de crear el modelo, debe crear una configuración de punto final ejecutando el siguiente comando (tenga en cuenta el tipo de instancia que estamos usando):

client.create_endpoint_config(
    EndpointConfigName= ,
    ProductionVariants=[
        {
         "VariantName": "v0",
         "ModelName": "Your model name",
         "InitialInstanceCount": 1,
         "InstanceType": "ml.c7g.xlarge",
        },
    ]
)

La siguiente captura de pantalla muestra los detalles de configuración del punto final en la consola de SageMaker.

Lanzar el punto final

Con la configuración del punto final creada en el paso anterior, puede implementar el punto final:

client.create_endpoint(
    EndpointName = "",
    EndpointConfigName = ""
    )

Espere hasta que se implemente el punto final de su modelo. Las predicciones se pueden solicitar de la misma manera que solicita predicciones para sus puntos finales implementados en instancias basadas en x86.

La siguiente captura de pantalla muestra su terminal en la consola de SageMaker.

lo que es compatible

SageMaker proporciona contenedores profundos Graviton de rendimiento optimizado para los marcos TensorFlow y PyTorch. Estos contenedores son compatibles con la visión artificial, el procesamiento del lenguaje natural, las recomendaciones y los casos de uso genéricos de inferencia basados ​​en modelos amplios y profundos. Además de los contenedores de aprendizaje profundo, SageMaker también proporciona contenedores para marcos de trabajo de aprendizaje automático clásicos, como XGBoost y Scikit-learn. Los contenedores son compatibles binariamente en las instancias c6g/m6g y c7g, por lo que la migración de la aplicación de inferencia de una generación a otra es sencilla.

C6g/m6g es compatible con fp16 (flotación de precisión media) y para los modelos compatibles proporciona un rendimiento equivalente o mejor en comparación con las instancias c5. C7g aumenta sustancialmente el rendimiento de ML al duplicar el ancho de SIMD y admitir bfloat-16 (bf16), que es la plataforma más rentable para ejecutar sus modelos.

Tanto c6g/m6g como c7g brindan un buen rendimiento para el aprendizaje automático clásico (por ejemplo, XGBoost) en comparación con otras instancias de CPU en SageMaker. La compatibilidad con Bfloat-16 en c7g permite la implementación eficiente de modelos capacitados con bf16 o AMP (Precisión mixta automática). El backend Arm Compute Library (ACL) en Graviton proporciona kernels bfloat-16 que pueden acelerar incluso los operadores fp32 a través del modo matemático rápido, sin la cuantificación del modelo.

Mejores prácticas recomendadas

En las instancias de Graviton, cada vCPU es un núcleo físico. No hay competencia por los recursos de CPU comunes (a diferencia de SMT), y la escala del rendimiento de la carga de trabajo es lineal con cada adición de vCPU. Por lo tanto, se recomienda utilizar la inferencia por lotes siempre que el caso de uso lo permita. Esto permitirá el uso eficiente de las vCPU mediante el procesamiento paralelo del lote en cada núcleo físico. Si la inferencia por lotes no es posible, se requiere el tamaño de instancia óptimo para una carga útil determinada para garantizar que la sobrecarga de programación de subprocesos del sistema operativo no supere la potencia de cómputo que viene con las vCPU adicionales.

TensorFlow viene con kernels Eigen de forma predeterminada y se recomienda cambiar a OneDNN con ACL para obtener el backend de inferencia más optimizado. El backend OneDNN y el modo matemático rápido bfloat-16 se pueden habilitar al iniciar el servicio de contenedor:

docker run -p 8501:8501 --name tfserving_resnet 
--mount type=bind,source=/tmp/resnet,target=/models/resnet 
-e MODEL_NAME=resnet -e TF_ENABLE_ONEDNN_OPTS=1 
-e DNNL_DEFAULT_FPMATH_MODE=BF16 -e -t tfs:mkl_aarch64

El comando de servicio anterior alberga un modelo resnet50 estándar con dos configuraciones importantes:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Estos se pueden pasar al contenedor de inferencia de la siguiente manera:

client.create_model(
    ModelName="Your model name",
    PrimaryContainer={
    "Image": ,
    "ModelDataUrl": ,
    "Environment": {
        "SAGEMAKER_PROGRAM": "inference.py",
        "SAGEMAKER_SUBMIT_DIRECTORY": "",
        "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
        "SAGEMAKER_REGION": ,
        "TF_ENABLE_ONEDNN_OPTS": "1",
        "DNNL_DEFAULT_FPMATH_MODE": "BF16"
         }
     },
     ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole'
)

Ejemplo de implementación

En esta publicación, le mostramos cómo implementar un modelo de TensorFlow, entrenado en SageMaker, en una instancia de inferencia de SageMaker con tecnología de Graviton.

Puede ejecutar el ejemplo de código en una instancia de cuaderno de SageMaker, un Estudio Amazon SageMaker notebook o un notebook Jupyter en modo local. Debe recuperar la función de ejecución de SageMaker si usa un cuaderno Jupyter en modo local.

El siguiente ejemplo considera el conjunto de datos CIFAR-10. Puede seguir el ejemplo del cuaderno de los ejemplos de SageMaker Repositorio GitHub para reproducir el modelo que se utiliza en esta publicación. Usamos el modelo entrenado y el cifar10_keras_principal.py Script Python para inferencia.

El modelo se almacena en un depósito S3: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

El cifar10_keras_main.py script, que se puede utilizar para la inferencia, se almacena en:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Usamos la us-east-1 Regione e implemente el modelo en una instancia basada en Graviton ml.c7g.xlarge. En base a esto, el URI de nuestro contenedor de aprendizaje profundo de AWS es 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. Configure con el siguiente código:

   import sagemaker
   import boto3
   import datetime
   import json
   import gzip
   import os
   
   sagemaker_session = sagemaker.Session()
   bucket = sagemaker_session.default_bucket()
   role = sagemaker.get_execution_role()
   region = sagemaker_session.boto_region_name

2. Descargue el conjunto de datos para las pruebas de punto final:

   from keras.datasets import cifar10
   (x_train, y_train), (x_test, y_test) = cifar10.load_data()

3. Cree el modelo y la configuración del punto final, e implemente el punto final:

   timestamp = "{:%Y-%m-%d-%H-%M-%S}".format(datetime.datetime.now())
   
   client = boto3.client("sagemaker")
   
   MODEL_NAME = f"graviton-model-{timestamp}"
   ENDPOINT_NAME = f"graviton-endpoint-{timestamp}"
   ENDPOINT_CONFIG_NAME = f"graviton-endpoint-config-{timestamp}"
   
   # create sagemaker model
   create_model_response = client.create_model(
       ModelName=MODEL_NAME,
       PrimaryContainer={
       "Image":  "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker ",
       "ModelDataUrl":  "s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz",
       "Environment": {
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": region
           }
       },
       ExecutionRoleArn=role
   )
   print ("create_model API response", create_model_response)

4. Opcionalmente, puede agregar su script de inferencia a Environment in create_model si no lo agregó originalmente como un artefacto a su modelo de SageMaker durante el entrenamiento:

   "SAGEMAKER_PROGRAM": "inference.py",
   "SAGEMAKER_SUBMIT_DIRECTORY": ,
   		
   # create sagemaker endpoint config
   create_endpoint_config_response = client.create_endpoint_config(
       EndpointConfigName=ENDPOINT_CONFIG_NAME,
       ProductionVariants=[
           {
            "VariantName": "v0",
            "ModelName": MODEL_NAME,
            "InitialInstanceCount": 1,
            "InstanceType": "ml.c7g.xlarge" 
           },
       ]
   )
   print ("ncreate_endpoint_config API response", create_endpoint_config_response)
   
   # create sagemaker endpoint
   create_endpoint_response = client.create_endpoint(
       EndpointName = ENDPOINT_NAME,
       EndpointConfigName = ENDPOINT_CONFIG_NAME,
   )
   print ("ncreate_endpoint API response", create_endpoint_response)   
   

   Tienes que esperar un par de minutos para que se lleve a cabo la implementación.

5. Verifique el estado del punto final con el siguiente código:

   describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
   print(describe_response["EndpointStatus"]

   También puede consultar la Consola de administración de AWS para ver cuándo se implementa su modelo.

6. Configure el entorno de tiempo de ejecución para invocar los puntos finales:

   runtime = boto3.Session().client(service_name="runtime.sagemaker")

   Ahora preparamos la carga útil para invocar el punto final. Utilizamos el mismo tipo de imágenes utilizadas para el entrenamiento del modelo. Estos se descargaron en pasos anteriores.

7. Convierta la carga útil en tensores y establezca el formato correcto que espera el modelo. Para este ejemplo, solo solicitamos una predicción.

   input_image = x_test[0].reshape(1,32,32,3)

   Obtenemos la salida del modelo como una matriz.

8. Podemos convertir esta salida en probabilidades si le aplicamos un softmax:

   CONTENT_TYPE = 'application/json'
   ACCEPT = 'application/json'
   PAYLOAD = json.dumps(input_image.tolist())
   
   response = runtime.invoke_endpoint(
       EndpointName=ENDPOINT_NAME, 
       ContentType=CONTENT_TYPE,
       Accept=ACCEPT,
       Body=PAYLOAD
   )
       
   print(response['Body'].read().decode())

Limpiar recursos

Los servicios involucrados en esta solución incurren en costos. Cuando haya terminado de usar esta solución, limpie los siguientes recursos:

client.delete_endpoint(EndpointName=ENDPOINT_NAME)
client.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
client.delete_model(ModelName=MODEL_NAME)

Comparación precio-rendimiento

Las instancias basadas en Graviton ofrecen el precio más bajo y la mejor relación precio-rendimiento en comparación con las instancias basadas en x86. De forma similar a las instancias EC2, los extremos de inferencia de SageMaker con instancias ml.c6g (Graviton 2) ofrecen un precio un 20 % más bajo en comparación con ml.c5, y las instancias Graviton 3 ml.c7g son un 15 % más baratas que las instancias ml.c6. Para obtener más información, consulte Precios de Amazon SageMaker.

Conclusión

En esta publicación, mostramos la capacidad SageMaker recientemente lanzada para implementar modelos en instancias de inferencia impulsadas por Graviton. Le brindamos orientación sobre las mejores prácticas y discutimos brevemente los beneficios de precio-rendimiento del nuevo tipo de instancias de inferencia.

Para obtener más información sobre Graviton, consulte Procesador gravitón AWS. Puede comenzar con las instancias EC2 basadas en Graviton de AWS en la consola de Amazon EC2 y consultando Guía técnica de AWS Graviton. Puede implementar un punto final de modelo de Sagemaker para inferencia en Graviton con el código de muestra en esta publicación de blog.

Sobre los autores

Víctor Jaramillo, PhD, es ingeniero sénior de aprendizaje automático en los servicios profesionales de AWS. Antes de AWS, fue profesor universitario e investigador científico en mantenimiento predictivo. En su tiempo libre, disfruta andar en motocicleta y hacer bricolaje en mecánica de motocicletas.

Dr. Zmnako Awrahman, es miembro de Practice Manager, ML SME y Machine Learning Technical Field Community (TFC) en Amazon Web Services. Ayuda a los clientes a aprovechar el poder de la nube para extraer valor de sus datos con análisis de datos y aprendizaje automático.

Sunita Nadampalli es gerente de desarrollo de software en AWS. Dirige las optimizaciones de rendimiento del software Graviton para cargas de trabajo multimedia, HPC y de aprendizaje automático. Le apasiona el desarrollo de código abierto y la entrega de soluciones de software rentables con Arm SoC.

Juana Liu es ingeniero de desarrollo de software en el equipo de Amazon SageMaker. Su trabajo actual se centra en ayudar a los desarrolladores a alojar de manera eficiente modelos de aprendizaje automático y mejorar el rendimiento de la inferencia. Le apasiona el análisis de datos espaciales y el uso de IA para resolver problemas sociales.

alan bronceado es gerente sénior de productos en SageMaker y lidera los esfuerzos en la inferencia de modelos grandes. Le apasiona aplicar el aprendizaje automático al área de análisis. Fuera del trabajo, disfruta del aire libre.