Cómo Patsnap usó la inferencia GPT-2 en Amazon SageMaker con latencia y costo reducidos

Esta publicación de blog fue escrita en colaboración e incluye una introducción de Zilong Bai, ingeniero sénior de procesamiento de lenguaje natural en Patsnap.

Probablemente esté familiarizado con la función de sugerencia de autocompletar cuando busca algo en Google o Amazon. Aunque los términos de búsqueda en estos escenarios son palabras clave o frases bastante comunes que usamos en la vida diaria, en algunos casos los términos de búsqueda son muy específicos del escenario. La investigación de patentes es una de ellas. Recientemente, el Centro de innovación de IA generativa de AWS colaboró ​​con Patsnap para implementar una función para sugerir automáticamente palabras clave de búsqueda como exploración de innovación para mejorar las experiencias de los usuarios en su plataforma.

Patsnap proporciona una plataforma global única para la investigación, el análisis y la gestión de patentes. Utilizan big data (como un historial de consultas de búsqueda anteriores) para proporcionar muchas herramientas de patentes potentes pero fáciles de usar. Estas herramientas han permitido a los clientes globales de Patsnap obtener una mejor comprensión de las patentes, realizar un seguimiento de los avances tecnológicos recientes, identificar tendencias de innovación y analizar a los competidores en tiempo real.

Al mismo tiempo, Patsnap está aprovechando el poder del aprendizaje automático (ML) para desarrollar funciones que pueden mejorar continuamente las experiencias de los usuarios en la plataforma. Una iniciativa reciente tiene como objetivo simplificar la dificultad de construir frases de búsqueda completando automáticamente las consultas de búsqueda de patentes utilizando modelos de generación de texto de última generación. Patsnap había entrenado un modelo GPT-2 personalizado para este propósito. Dado que no existe tal funcionalidad en ningún motor de búsqueda de patentes (hasta donde ellos saben), Patsnap cree que agregar esta funcionalidad aumentará la aceptación por parte del usuario final.

Sin embargo, en sus experimentos recientes, la latencia de inferencia y las solicitudes por segundo (RPS) de un modelo GPT-2 basado en PyTorch no alcanzaron ciertos umbrales que podrían justificar su valor comercial. Para abordar este desafío, los científicos del Centro de innovación de IA generativa de AWS exploraron varias soluciones para optimizar el rendimiento de inferencia de GPT-2, lo que redujo la latencia del modelo en un 50 % en promedio y mejoró el QPS en un 200 %.

Grandes desafíos de inferencia del modelo de lenguaje y enfoques de optimización

En general, la aplicación de un modelo tan grande en un entorno de producción real no es trivial. El costo computacional prohibitivo y la latencia de GPT-2 basado en PyTorch han dificultado su adopción generalizada desde la perspectiva de las operaciones comerciales. En este proyecto, nuestro objetivo es mejorar significativamente la latencia con costos computacionales razonables. Específicamente, Patsnap requiere lo siguiente:

• La latencia promedio de la inferencia del modelo para generar expresiones de búsqueda debe controlarse dentro de los 600 milisegundos en escenarios de búsqueda en tiempo real
• El modelo requiere un alto rendimiento y RPS para realizar una gran cantidad de búsquedas por segundo durante las horas pico.

En este artículo, analizamos nuestros hallazgos utilizando instancias de Amazon Elastic Compute Cloud (Amazon EC2), con instancias basadas en GPU que utilizan NVIDIA TensorRT.

En resumen, usamos NVIDIA TensorRT para optimizar la latencia de GPT-2 e implementarlo en un punto final de Amazon SageMaker para el servicio de modelos, reduciendo la latencia promedio de 1172 milisegundos a 531 milisegundos.

En las siguientes secciones, revisamos los detalles técnicos de las soluciones propuestas con fragmentos de código clave y mostramos comparaciones con el status quo del cliente en función de métricas clave.

Presentación del modelo GPT-2

El GPT-2 de Open AI es un gran transformadorbasado en un modelo de lenguaje con 1.500 millones de parámetros, entrenado en el conjunto de datos WebText, que contiene 8 millones de páginas web. El GPT-2 está entrenado con un objetivo simple: predecir la siguiente palabra, dadas todas las palabras anteriores en un texto. La diversidad del conjunto de datos hace que este simple objetivo contenga demostraciones naturales de muchas tareas en varios campos. GPT-2 muestra una amplia gama de funciones, incluida la capacidad de generar muestras de texto sintético condicional de una calidad sin precedentes, donde arrancamos el modelo con una entrada y dejamos que genere una ejecución larga. En esta situación, lo aprovechamos para generar consultas de búsqueda. A medida que los modelos de GPT continúan creciendo, los costos de inferencia aumentan continuamente, lo que aumenta la necesidad de implementar estos modelos a un costo aceptable.

Logre una baja latencia en las instancias de GPU a través de TensorRT

TensorRT es una biblioteca de C++ para inferencia de alto rendimiento en GPU NVIDIA y aceleradores de aprendizaje profundo, compatible con los principales marcos de aprendizaje profundo, como PyTorch y TensorFlow. Estudios anteriores han mostrado una gran mejora en el rendimiento en términos de latencia del modelo. Por lo tanto, es una opción ideal para nosotros para reducir la latencia del modelo de destino en las GPU NVIDIA.

Podemos lograr una reducción significativa en la latencia de inferencia del modelo GPT-2 con un modelo basado en TensorRT en GPU NVIDIA. El modelo basado en TensorRT se implementa a través de SageMaker para realizar pruebas de rendimiento. En este artículo, mostramos los pasos para convertir el modelo GPT-2 original basado en PyTorch en un modelo basado en TensorRT.

Convertir GPT-2 basado en PyTorch a un modelo basado en TensorRT no es difícil a través de la herramienta oficial proporcionada por Nvidia. Además, con conversiones tan simples, no se observó una degradación evidente de la precisión del modelo. En general, hay tres pasos a seguir:

1. Analiza tu GPT-2. Al momento de escribir este artículo, la herramienta de conversión de NVIDIA solo es compatible con la versión Hugging Face del modelo GPT-2. Si el modelo GPT-2 actual no es la versión original, debe modificarlo en consecuencia. Se recomienda eliminar el código personalizado de la implementación original de GPT-2 de Hugging Face, que es muy útil para la conversión.
2. Instale los paquetes de Python necesarios. El proceso de conversión primero convierte el modelo basado en PyTorch al modelo ONNX, luego convierte el modelo basado en ONNX al modelo basado en TensorRT. Se requieren los siguientes paquetes de Python para esta conversión de dos pasos:

tabulate
toml
torch
sentencepiece==0.1.95
onnx==1.9.0
onnx_graphsurgeon
polygraphy
transformers

3. Convierte tu modelo. El siguiente código contiene las funciones para la conversión en dos pasos:

def torch2onnx():
    metadata = NetworkMetadata(variant=GPT2_VARIANT, precision=Precision(fp16=True), other=GPT2Metadata(kv_cache=False))
    gpt2 = GPT2TorchFile(model.to('cpu'), metadata)
    onnx_path = ('Your own path to save ONNX-based model') # e.g, ./model_fp16.onnx
    gpt2.as_onnx_model(onnx_path, force_overwrite=False)
    return onnx_path, metadata
   
def onnx2trt(onnx_path, metadata):
    trt_path="Your own path to save TensorRT-based model" # e.g., ./model_fp16.onnx.engine
    batch_size = 10
    max_sequence_length = 42
    profiles = [Profile().add(
        "input_ids",
        min=(1, 1),
        opt=(batch_size, max_sequence_length // 2),
        max=(batch_size, max_sequence_length),
    )]
    gpt2_engine = GPT2ONNXFile(onnx_path, metadata).as_trt_engine(output_fpath=trt_path, profiles=profiles)
    gpt2_trt = GPT2TRTDecoder(gpt2_engine, metadata, config, max_sequence_length=42, batch_size=10)

Comparación de latencia: PyTorch y TensorRT

JMeter se utiliza para la evaluación comparativa del rendimiento en este proyecto. Jmetro es un proyecto de Apache que se puede utilizar como herramienta de prueba de carga para analizar y medir el rendimiento de varios servicios. Registramos el QPS y la latencia del modelo original basado en PyTorch y nuestro modelo GPT-2 basado en TensorRT convertido en una instancia AWS P3.2xlarge. Como mostramos más adelante en este artículo, debido a la poderosa capacidad de aceleración de TensorRT, la latencia de GPT-2 se reduce significativamente. Cuando la simultaneidad de solicitudes es 1, la latencia promedio se redujo en 274 milisegundos (2,9 veces más rápido). Desde una perspectiva de QPS, pasó de 2,4 a 7, lo que representa un aumento de aproximadamente 2,9 veces con respecto al modelo original basado en PyTorch. Además, a medida que aumenta la simultaneidad, QPS continúa aumentando. Esto sugiere costos más bajos con un aumento aceptable en la latencia (pero mucho más rápido que el modelo original).

La siguiente tabla compara la latencia:

Implemente GPT-2 basado en TensorRT con SageMaker y un contenedor personalizado

GPT-2 basado en TensorRT requiere una versión relativamente reciente de TensorRT, por lo que elegimos el modo traer su propio contenedor (BYOC) de SageMaker para implementar nuestro modelo. El modo BYOC proporciona una forma flexible de implementar la plantilla y puede crear entornos personalizados en su propio contenedor de Docker. En esta sección, mostramos cómo crear su propio contenedor, implementar su propia plantilla GPT-2 y probar con la API de SageMaker Endpoint.

Construye tu propio contenedor

El directorio de archivos del contenedor se muestra en el siguiente código. Específicamente, Dockerfile Y build.sh se utilizan para construir el contenedor Docker. gpt2 Y predictor.py implementar el modelo de inferencia y la API. serve, nginx.confY wsgi.py proporcionar la configuración del servidor web NGINX.

container
├── Dockerfile    # build our docker based on this file.
├── build.sh      # create our own image and push it to Amazon ECR
├── gpt2          # model directory
├── predictor.py  # backend function for invoke the model
├── serve         # web server setting file
├── nginx.conf    # web server setting file
└── wsgi.py       # web server setting file

Tu puedes correr sh ./build.sh para construir el contenedor.

Implementar en un punto final de SageMaker

Después de crear un contenedor para ejecutar GPT-2 basado en TensorRT, puede habilitar la inferencia en tiempo real a través de un punto final de SageMaker. Utilice los siguientes fragmentos de código para crear el punto final e implementar el modelo en el punto final mediante las API de SageMaker correspondientes:

import boto3from time import gmtime, strftime
from sagemaker import get_execution_role

sm_client = boto3.client(service_name="sagemaker")
runtime_sm_client = boto3.client(service_name="sagemaker-runtime")
account_id = boto3.client('sts').get_caller_identity()['Account']
region = boto3.Session().region_name
s3_bucket="${Your s3 bucket}"
role = get_execution_role()
model_name="${Your Model Name}"
# you need to upload your container to S3 first
container="${Your Image Path}"
instance_type="ml.p3.2xlarge"
container = {
    'Image': container
}
create_model_response = sm_client.create_model(
    ModelName = model_name,
    ExecutionRoleArn = role,
    Containers = [container])
    
# Endpoint Setting
endpoint_config_name="${Your Endpoint Config Name}"
print('Endpoint config name: ' + endpoint_config_name)
create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName = endpoint_config_name,
    ProductionVariants=[{
        'InstanceType': instance_type,
        'InitialInstanceCount': 1,
        'InitialVariantWeight': 1,
        'ModelName': model_name,
        'VariantName': 'AllTraffic'}])
print("Endpoint config Arn: " + create_endpoint_config_response['EndpointConfigArn'])

# Deploy Model
endpoint_name="${Your Endpoint Name}"
print('Endpoint name: ' + endpoint_name)
create_endpoint_response = sm_client.create_endpoint(
    EndpointName=endpoint_name,
    EndpointConfigName=endpoint_config_name)
print('Endpoint Arn: ' + create_endpoint_response['EndpointArn'])
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp['EndpointStatus']
print("Endpoint Status: " + status)
print('Waiting for {} endpoint to be in service...'.format(endpoint_name))
waiter = sm_client.get_waiter('endpoint_in_service')
waiter.wait(EndpointName=endpoint_name)

Probar el modelo desplegado

Una vez que el modelo se haya implementado correctamente, puede probar el punto final a través de la instancia del cuaderno de SageMaker con el siguiente código:

import json
import boto3

sagemaker_runtime = boto3.client("sagemaker-runtime", region_name="us-east-2")
endpoint_name = "${Your Endpoint Name}"
request_body = {"input": "amazon"}
payload = json.dumps(request_body)
content_type = "application/json"
response = sagemaker_runtime.invoke_endpoint(
                            EndpointName=endpoint_name,
                            ContentType=content_type,
                            Body=payload # Replace with your own data.
                            )
result = json.loads(response['Body'].read().decode())
print(result)

Conclusión

En este artículo, describimos cómo habilitar la inferencia GPT-2 de baja latencia en SageMaker para crear valor empresarial. Específicamente, con la compatibilidad con NVIDIA TensorRT, podemos lograr una aceleración de 2,9 veces en las instancias de NVIDIA GPU con SageMaker para un modelo GPT-2 personalizado.

Si necesita ayuda para acelerar el uso de modelos GenAI en sus productos y servicios, comuníquese con el Centro de innovación de IA generativa de AWS. El Centro de innovación de IA generativa de AWS puede ayudarlo a hacer realidad sus ideas de manera más rápida y eficiente. Para comenzar con el Centro de innovación de IA generativa, vaya aquí.

Sobre los autores

hao huang es científico aplicado en el Centro de innovación de IA generativa de AWS. Se especializa en Visión por Computador (CV) y Modelo de Lenguaje Visual (VLM). Recientemente, ha desarrollado un gran interés en las tecnologías de IA generativa y ha trabajado anteriormente con clientes para aplicar estas tecnologías avanzadas a sus negocios. También es revisor de conferencias de IA como ICCV y AAAI.

Bai Zilong es ingeniero sénior de procesamiento del lenguaje natural en Patsnap. Le apasiona la investigación y el trabajo de prueba de concepto sobre técnicas de vanguardia para modelos de lenguaje generativo.

Yuan Jun Xiao es arquitecto de soluciones en AWS. Es el responsable de consultar y diseñar la arquitectura de AWS. También le apasiona crear soluciones de inteligencia artificial y análisis.

Xuefei Zhang es científico aplicado en el AWS Generative AI Innovation Center, trabaja en NLP y AGI para resolver problemas de la industria con los clientes.

Cantón es un científico aplicado sénior en el Centro de innovación de IA generativa de AWS, donde trabaja con clientes en varias verticales y aplica la resolución creativa de problemas para generar valor para los clientes con soluciones de ML/IA de vanguardia.