Implemente BLOOM-176B y OPT-30B en Amazon SageMaker con inferencia de modelos grandes Contenedores de aprendizaje profundo y DeepSpeed

Los últimos años han visto un rápido desarrollo en el campo del aprendizaje profundo. Si bien el hardware ha mejorado, como con la última generación de aceleradores de NVIDIA y Amazon, los profesionales del aprendizaje automático (ML) avanzado aún encuentran problemas al implementar sus grandes modelos de aprendizaje profundo para aplicaciones como el procesamiento del lenguaje natural (NLP).

En una publicación anterior, discutimos capacidades y ajustes configurables in Implementación de modelos de Amazon SageMaker que pueden facilitar la inferencia con estos modelos grandes. Hoy anunciamos un nuevo Amazon SageMaker Contenedor de aprendizaje profundo (DLC) que puede usar para comenzar con la inferencia de modelos grandes en cuestión de minutos. Este DLC empaqueta algunas de las bibliotecas de código abierto más populares para la inferencia paralela de modelos, como DeepSpeed ​​y Hugging Face Accelerate.

En esta publicación, usamos un nuevo DLC de inferencia de modelos grandes de SageMaker para implementar dos de los modelos grandes de NLP más populares: BigScience's FLORACIÓN-176B y los de Meta OPT-30B del repositorio Hugging Face. En particular, utilizamos técnicas de paralelismo de tensor y servidor de Deep Java Library (DJL) de DeepSpeed ​​para lograr una latencia de 0.1 segundos por token en un caso de uso de generación de texto.

Puede encontrar nuestros cuadernos de ejemplo completos en nuestro Repositorio GitHub.

Técnicas de inferencia de modelos grandes

Los modelos de lenguaje se han disparado recientemente tanto en tamaño como en popularidad. Con fácil acceso desde zoológicos de modelos como Hugging Face y precisión y rendimiento mejorados en tareas de PNL como clasificación y generación de texto, los profesionales buscan cada vez más estos grandes modelos. Sin embargo, los modelos grandes suelen ser demasiado grandes para caber en la memoria de un solo acelerador. Por ejemplo, el modelo BLOOM-176B puede requerir más de 350 gigabytes de memoria del acelerador, lo que supera con creces la capacidad de los aceleradores de hardware disponibles en la actualidad. Esto requiere el uso de técnicas paralelas de modelos de bibliotecas como DeepSpeed ​​y Hugging Face Accelerate para distribuir un modelo a través de múltiples aceleradores para la inferencia. En esta publicación, usamos el Contenedor de inferencia de modelo grande de SageMaker para generar y comparar la latencia y el rendimiento mediante el uso de estas dos bibliotecas de código abierto.

DeepSpeed ​​y Accelerate usan diferentes técnicas para optimizar los modelos de lenguaje grandes para la inferencia. La diferencia clave es DeepSpeed uso de núcleos optimizados. Estos núcleos pueden mejorar drásticamente la latencia de inferencia al reducir los cuellos de botella en el gráfico de cálculo del modelo. Los núcleos optimizados pueden ser difíciles de desarrollar y, por lo general, son específicos de una arquitectura de modelo en particular; DeepSpeed ​​es compatible con modelos grandes populares como OPT y BLOOM con estos núcleos optimizados. Por el contrario, la biblioteca Accelerate de Hugging Face no incluye núcleos optimizados en el momento de escribir este artículo. Como discutimos en nuestra sección de resultados, esta diferencia es responsable de gran parte de la ventaja de rendimiento que DeepSpeed ​​tiene sobre Accelerate.

Una segunda diferencia entre DeepSpeed ​​y Accelerate es el tipo de paralelismo del modelo. Accelerate usa el paralelismo de canalización para dividir un modelo entre las capas ocultas de un modelo, mientras que DeepSpeed ​​usa el paralelismo de tensor para dividir las capas. El paralelismo de canalización es un enfoque flexible que admite más tipos de modelos y puede mejorar el rendimiento cuando se utilizan tamaños de lote más grandes. El paralelismo de tensor requiere más comunicación entre las GPU porque las capas del modelo se pueden distribuir en varios dispositivos, pero pueden mejorar la latencia de inferencia al involucrar varias GPU simultáneamente. Puede obtener más información sobre las técnicas de paralelismo en Introducción al paralelismo de modelos y Modelo de paralelismo.

Resumen de la solución

Para alojar modelos de lenguaje grandes de manera eficaz, necesitamos características y soporte en las siguientes áreas clave:

• Construyendo y probando soluciones. – Dada la naturaleza iterativa del desarrollo de ML, necesitamos la capacidad de construir, iterar rápidamente y probar cómo se comportará el punto final de inferencia cuando estos modelos estén alojados, incluida la capacidad de fallar rápidamente. Por lo general, estos modelos solo se pueden alojar en instancias más grandes como p4dn o g5 y, dado el tamaño de los modelos, puede llevar un tiempo activar una instancia de inferencia y ejecutar cualquier iteración de prueba. Las pruebas locales generalmente tienen restricciones porque necesita una instancia de tamaño similar para probar, y estos modelos no son fáciles de obtener.
• Implementación y ejecución a escala – Los archivos del modelo deben cargarse en las instancias de inferencia, lo que presenta un desafío en sí mismo dado el tamaño. Tar / Un-Tar como ejemplo para el Bloom-176B tarda aproximadamente 1 hora en crearse y otra hora en cargarse. Necesitamos un mecanismo alternativo para permitir un fácil acceso a los archivos del modelo.
• Cargando el modelo como singleton – Para un proceso de varios trabajadores, debemos asegurarnos de que el modelo se cargue solo una vez para que no nos encontremos en condiciones de carrera y gastemos más recursos innecesarios. En esta publicación, mostramos una forma de cargar directamente desde Servicio de almacenamiento simple de Amazon (Amazon S3). Sin embargo, esto solo funciona si usamos la configuración predeterminada del DJL. Además, cualquier escalado de los puntos finales debe poder activarse en unos minutos, lo que exige reconsiderar cómo se pueden cargar y distribuir los modelos.
• Marcos de fragmentación – Por lo general, estos modelos deben ser , generalmente mediante un mecanismo de paralelismo de tensor o fragmentación de tubería como las técnicas típicas de fragmentación, y tenemos conceptos avanzados como la fragmentación ZeRO construida sobre la fragmentación de tensor. Para obtener más información acerca de las técnicas de fragmentación, consulte Modelo de paralelismo. Para conseguirlo podemos tener varias combinaciones y utilizar frameworks de NIVIDIA, DeepSpeed ​​y otros. Esto necesita la capacidad de probar BYOC o usar contenedores 1P e iterar sobre soluciones y ejecutar pruebas de evaluación comparativa. También es posible que desee probar varias opciones de alojamiento, como asíncrono, sin servidor y otros.
• Selección de hardware – Su elección de hardware está determinada por todos los puntos mencionados anteriormente y otros patrones de tráfico, necesidades de casos de uso y tamaños de modelos.

En esta publicación, usamos los núcleos optimizados de DeepSpeed ​​y las técnicas de paralelismo de tensor para alojar BLOOM-176B y OPT-30B en SageMaker. También comparamos los resultados de Accelerate para demostrar los beneficios de rendimiento de los núcleos optimizados y el paralelismo de tensores. Para obtener más información sobre DeepSpeed ​​y Accelerate, consulte Inferencia de DeepSpeed: habilitación de la inferencia eficiente de modelos de transformadores a una escala sin precedentes y Inferencia BLOOM increíblemente rápida con DeepSpeed ​​y Accelerate.

Usamos DJLServing como la solución de servicio modelo en este ejemplo. DJLServing es una solución de servicio de modelo universal de alto rendimiento impulsada por Deep Java Library (DJL) que es independiente del lenguaje de programación. Para obtener más información sobre DJL y DJLServing, consulte Implemente modelos grandes en Amazon SageMaker mediante la inferencia paralela de modelos DJLServing y DeepSpeed.

Vale la pena señalar que los núcleos optimizados pueden dar como resultado cambios de precisión y un gráfico de cálculo modificado, lo que teóricamente podría dar como resultado un cambio en el comportamiento del modelo. Aunque esto podría cambiar ocasionalmente el resultado de la inferencia, no esperamos que estas diferencias afecten materialmente las métricas de evaluación básicas de un modelo. Sin embargo, se recomienda a los profesionales que confirmen que los resultados del modelo son los esperados al usar estos núcleos.

Los siguientes pasos demuestran cómo implementar un modelo BLOOM-176B en SageMaker mediante DJLServing y un contenedor de inferencia de modelo grande de SageMaker. El ejemplo completo también está disponible en nuestro Repositorio GitHub.

Uso de la imagen DLC DJLServing SageMaker

Use el siguiente código para usar la imagen DLC DJLServing SageMaker después de reemplazar la región con su región específica en la que está ejecutando la computadora portátil:

763104351884.dkr.ecr..amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113
# example uri might be like 763104351884.dkr.ecr.us-east-1.amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113

Crear nuestro archivo modelo

Primero, creamos un archivo llamado serving.properties que contiene sólo una línea de código. Esto le dice al servidor modelo DJL que use el motor DeepSpeed. El archivo contiene el siguiente código:

engine=DeepSpeed

serving.properties es un archivo definido por DJLServing que se utiliza para configurar la configuración por modelo.

A continuación, creamos nuestro model.py archivo, que define el código necesario para cargar y luego servir el modelo. En nuestro código, leemos en el TENSOR_PARALLEL_DEGREE variable de entorno (el valor predeterminado es 1). Establece el número de dispositivos sobre los que se distribuyen los módulos paralelos tensoriales. Tenga en cuenta que DeepSpeed ​​proporciona algunas definiciones de partición integradas, incluida una para los modelos BLOOM. Lo usamos especificando replace_method y relpace_with_kernel_inject. Si tiene un modelo personalizado y necesita DeepSpeed ​​para particionar de manera efectiva, debe cambiar relpace_with_kernel_inject a false y añade injection_policy para hacer que la partición de tiempo de ejecución funcione. Para obtener más información, consulte Inicializar para inferencia. Para nuestro ejemplo, usamos el modelo BLOOM previamente particionado en DeepSpeed.

En segundo lugar, en el model.py archivo, también cargamos el modelo desde Amazon S3 después de que se haya activado el punto final. El modelo se carga en el /tmp espacio en el contenedor porque SageMaker mapea el /tmp En el correo electrónico “Su Cuenta de Usuario en su Nuevo Sistema XNUMXCX”. Tienda de bloques elásticos de Amazon (Amazon EBS) volumen que se monta cuando especificamos el parámetro de creación de punto final VolumeSizeInGB. Para instancias como p4dn, que vienen preconstruidas con la instancia de volumen, podemos continuar aprovechando la /tmp en el contenedor Ver el siguiente código:

from djl_python import Input, Output
import os
import deepspeed
import torch
import torch.distributed as dist
import sys
import subprocess
import time
from glob import glob
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from transformers.models.opt.modeling_opt import OPTDecoderLayer

predictor = None

def check_config():
    local_rank = os.getenv('LOCAL_RANK')
    
    if not local_rank:
        return False
    return True
    
def get_model():

    if not check_config():
        raise Exception("DJL:DeepSpeed configurations are not default. This code does not support non default configurations") 
    
    tensor_parallel = int(os.getenv('TENSOR_PARALLEL_DEGREE', '1'))
    local_rank = int(os.getenv('LOCAL_RANK', '0'))
    model_dir = "/tmp/model"
    bucket = os.environ.get("MODEL_S3_BUCKET")
    key_prefix = os.environ.get("MODEL_S3_PREFIX")
    print(f"rank: {local_rank}")
    if local_rank == 0:
        if f"{model_dir}/DONE" not in glob(f"{model_dir}/*"):
            print("Starting Model downloading files")
            try:
                proc_run = subprocess.run(
                    ["aws", "s3", "cp", "--recursive", f"s3://{bucket}/{key_prefix}", model_dir]
                )
                print("Model downloading finished")
                # write file when download complete. Could use dist.barrier() but this makes it easier to check if model is downloaded in case of retry
                with open(f"{model_dir}/DONE", "w") as f:
                    f.write("download_complete")
                    
                proc_run.check_returncode() # to throw the error in case there was one
                
            except subprocess.CalledProcessError as e:
                print ( "Model download failed: Error:nreturn code: ", e.returncode, "nOutput: ", e.stderr )
                raise # FAIL FAST  
                               
    dist.barrier()
                
    
    tokenizer = AutoTokenizer.from_pretrained(model_dir)
    
    # has to be FP16 as Int8 model loading not yet supported
    with deepspeed.OnDevice(dtype=torch.float16, device="meta"):
        model = AutoModelForCausalLM.from_config(
            AutoConfig.from_pretrained(model_dir), torch_dtype=torch.bfloat16
        )
    model = model.eval()
    
    model = deepspeed.init_inference(
        model,
        mp_size=tensor_parallel,
        dtype=torch.int8,
        base_dir = model_dir,
        checkpoint=os.path.join(model_dir, "ds_inference_config.json"),
        replace_method='auto',
        replace_with_kernel_inject=True
    )

    model = model.module
    dist.barrier()
    return model, tokenizer

DJLServing administra la instalación en tiempo de ejecución en cualquier paquete pip definido en requirement.txt. Este archivo tendrá:

awscli
boto3

Hemos creado un directorio llamado code y del model.py, serving.propertiesy requirements.txt los archivos ya están creados en este directorio. Para ver los archivos, puede ejecutar el siguiente código desde la terminal:

mkdir -p code
cat code/model.py 
cat code/serving.properties 
cat code/requirements.txt 

La siguiente figura muestra la estructura de la model.tar.gz.

Por último, creamos el archivo del modelo y lo subimos a Amazon S3:

tar cvfz model.tar.gz code
s3_code_artifact = sess.upload_data("model.tar.gz", bucket, s3_code_prefix)

Descarga y almacena el modelo de Hugging Face (Opcional)

Hemos proporcionado los pasos en esta sección en caso de que desee descargar el modelo a Amazon S3 y usarlo desde allí. Los pasos se proporcionan en el archivo de Jupyter en GitHub. La siguiente captura de pantalla muestra una instantánea de los pasos.

Crear un modelo de SageMaker

Ahora creamos un modelo de SageMaker. Utilizamos el Registro de contenedores elásticos de Amazon (Amazon ECR) proporcionada por y el artefacto del modelo del paso anterior para crear el modelo de SageMaker. En la configuración del modelo, configuramos TENSOR_PARALLEL_DEGREE=8, lo que significa que el modelo está dividido en 8 GPU. Ver el siguiente código:

PrimaryContainer={
        "Image": inference_image_uri,
        "ModelDataUrl": s3_code_artifact,
        "Environment": {
            "MODEL_S3_BUCKET": bucket,
            "MODEL_S3_PREFIX": s3_model_prefix,
            "TENSOR_PARALLEL_DEGREE": "8",
},

Después de ejecutar la celda anterior en el archivo Jupyter, verá un resultado similar al siguiente:

{
    "ModelArn": "arn:aws:sagemaker:us-east-1::model/bloom-djl-ds-"
}

Crear un punto final de SageMaker

Puede usar cualquier instancia con varias GPU para realizar pruebas. En esta demostración, usamos una instancia p4d.24xlarge. En el siguiente código, observe cómo configuramos el ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSecondsy VolumeSizeInGB parámetros para acomodar el gran tamaño del modelo. los VolumeSizeInGB El parámetro se aplica a las instancias de GPU que admiten el archivo adjunto de volumen de EBS.

endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.p4d.24xlarge",
            "InitialInstanceCount": 1,
            #"VolumeSizeInGB" : 200,
            "ModelDataDownloadTimeoutInSeconds": 2400,
            "ContainerStartupHealthCheckTimeoutInSeconds": 2400,
        },
    ],
)'

Por último, creamos un punto final de SageMaker:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)

Lo ves impreso en el siguiente código:

{
    "EndpointArn": "arn:aws:sagemaker:us-east-1::endpoint/bloom-djl-ds-"
}

Iniciar el punto final puede llevar un tiempo. Puedes intentarlo unas cuantas veces más si te encuentras con el InsufficientInstanceCapacity error, o puede enviar una solicitud a AWS para aumentar el límite en su cuenta.

Ajuste de rendimiento

Si tiene la intención de usar esta publicación y la computadora portátil que la acompaña con un modelo diferente, es posible que desee explorar algunos de los parámetros ajustables que ofrecen SageMaker, DeepSpeed ​​y DJL. La experimentación iterativa con estos parámetros puede tener un impacto material en la latencia, el rendimiento y el costo de su modelo grande alojado. Para obtener más información sobre los parámetros de ajuste, como la cantidad de trabajadores, el grado de paralelismo del tensor, el tamaño de la cola de trabajos y otros, consulte Configuraciones de servicio DJL y Implemente modelos grandes en Amazon SageMaker mediante la inferencia paralela de modelos DJLServing y DeepSpeed.

Resultados

En esta publicación, usamos DeepSpeed ​​para alojar BLOOM-176B y OPT-30B en instancias de SageMaker ML. La siguiente tabla resume nuestros resultados de rendimiento, incluida una comparación con Accelerate de Hugging Face. La latencia refleja la cantidad de milisegundos que lleva producir una cadena de 256 tokens cuatro veces (batch_size=4) del modelo. El rendimiento refleja la cantidad de tokens producidos por segundo para cada prueba. Para Hugging Face Accelerate, usamos la carga predeterminada de la biblioteca con asignación de memoria GPU. Para DeepSpeed, usamos su mecanismo de carga de punto de control más rápido.

Desde la perspectiva de la latencia, DeepSpeed ​​es aproximadamente 3.4 veces más rápido para BLOOM-176B y 5.6 veces más rápido para OPT-30B que Accelerate. Los núcleos optimizados de DeepSpeed ​​son responsables de gran parte de esta diferencia de latencia. Dados estos resultados, recomendamos usar DeepSpeed ​​sobre Accelerate si su modelo de elección es compatible.

También vale la pena señalar que los tiempos de carga del modelo con DeepSpeed ​​fueron mucho más cortos, lo que lo convierte en una mejor opción si anticipa la necesidad de escalar rápidamente su número de puntos finales. La técnica de paralelismo de canalización más flexible de Accelerate puede ser una mejor opción si tiene modelos o precisiones de modelo que no son compatibles con DeepSpeed.

Estos resultados también demuestran la diferencia en la latencia y el rendimiento de diferentes tamaños de modelos. En nuestras pruebas, OPT-30B genera 2.4 veces más tokens por unidad de tiempo que BLOOM-176B en un tipo de instancia que es más de tres veces más económico. En función del precio por rendimiento unitario, OPT-30B en una instancia g5.24xl es 8.9 veces mejor que BLOOM-176B en una instancia p4d.24xl. Si tiene limitaciones estrictas de latencia, rendimiento o costo, considere usar el modelo más pequeño posible que aún cumpla con los requisitos funcionales.

Limpiar

Como parte de las mejores prácticas, siempre se recomienda eliminar las instancias inactivas. El siguiente código le muestra cómo eliminar las instancias.

# - Delete the end point
sm_client.delete_endpoint(EndpointName=endpoint_name)

# - In case the end point failed we still want to delete the model
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)

Opcionalmente, elimine el punto de control del modelo de su S3

!aws s3 rm --recursive s3:///{s3_model_prefix}

Conclusión

En esta publicación, demostramos cómo usar los contenedores de inferencia de modelos grandes de SageMaker para alojar dos modelos de lenguaje grandes, BLOOM-176B y OPT-30B. Usamos las técnicas paralelas de modelos de DeepSpeed ​​con múltiples GPU en una sola instancia de SageMaker ML.

Para obtener más detalles sobre Amazon SageMaker y sus capacidades de inferencia de modelos grandes, consulte Amazon SageMaker ahora admite la implementación de modelos grandes a través de cuotas de tiempo de espera y tamaño de volumen configurables y Inferencia en tiempo real.

Sobre los autores

Simón Zamarin es un arquitecto de soluciones de IA / ML cuyo objetivo principal es ayudar a los clientes a extraer valor de sus activos de datos. En su tiempo libre, a Simon le gusta pasar tiempo con la familia, leer ciencia ficción y trabajar en varios proyectos de bricolaje.

Rupinder Grewal es un Arquitecto de Soluciones Sr. Ai/ML Especialista con AWS. Actualmente se enfoca en servir modelos y MLOps en SageMaker. Antes de este cargo, trabajó como ingeniero de aprendizaje automático creando y alojando modelos. Fuera del trabajo, le gusta jugar tenis y andar en bicicleta por senderos de montaña.

franco liu es un ingeniero de software para AWS Deep Learning. Se centra en la creación de herramientas innovadoras de aprendizaje profundo para ingenieros de software y científicos. En su tiempo libre, le gusta ir de excursión con amigos y familiares.

alan bronceado es gerente sénior de productos en SageMaker y lidera los esfuerzos en la inferencia de modelos grandes. Le apasiona aplicar Machine Learning al área de Analytics. Fuera del trabajo, disfruta del aire libre.

Patel Dhawal es Arquitecto Principal de Aprendizaje Automático en AWS. Ha trabajado con organizaciones que van desde grandes empresas hasta empresas emergentes medianas en problemas relacionados con la computación distribuida y la inteligencia artificial. Se enfoca en el aprendizaje profundo, incluidos los dominios de NLP y Computer Vision. Ayuda a los clientes a lograr una inferencia de modelos de alto rendimiento en SageMaker.

qing-lan es ingeniero de desarrollo de software en AWS. Ha estado trabajando en varios productos desafiantes en Amazon, incluidas soluciones de inferencia ML de alto rendimiento y un sistema de registro de alto rendimiento. El equipo de Qing lanzó con éxito el primer modelo de mil millones de parámetros en Amazon Advertising con una latencia muy baja requerida. Qing tiene un conocimiento profundo sobre la optimización de la infraestructura y la aceleración del aprendizaje profundo.

qingweili es un especialista en aprendizaje automático en Amazon Web Services. Recibió su Ph.D. en Investigación de Operaciones después de que rompió la cuenta de subvenciones de investigación de su asesor y no pudo entregar el Premio Nobel que prometió. Actualmente, ayuda a los clientes de la industria de seguros y servicios financieros a crear soluciones de aprendizaje automático en AWS. En su tiempo libre le gusta leer y enseñar.

Roberto Van Dusen es gerente sénior de productos en Amazon SageMaker. Lidera la optimización de modelos de aprendizaje profundo para aplicaciones como la inferencia de modelos grandes.

Siddharth Venkatesan es ingeniero de software en AWS Deep Learning. Actualmente se centra en la construcción de soluciones para la inferencia de modelos grandes. Antes de AWS, trabajó en la organización de Amazon Grocery creando nuevas funciones de pago para clientes de todo el mundo. Fuera del trabajo, le gusta esquiar, estar al aire libre y ver deportes.