Cómo Patsnap utilizó la inferencia de GPT-2 en Amazon SageMaker con baja latencia y costo

Uso eficiente de GPT-2 en Amazon SageMaker por Patsnap

Esta publicación de blog fue coescrita e incluye una introducción por Zilong Bai, ingeniero principal de procesamiento de lenguaje natural en Patsnap.

Es probable que estés familiarizado con la función de sugerencia de autocompletado cuando buscas algo en Google o Amazon. Aunque los términos de búsqueda en estos escenarios suelen ser palabras clave o expresiones comunes que usamos en la vida diaria, en algunos casos los términos de búsqueda son muy específicos para el escenario. La búsqueda de patentes es uno de ellos. Recientemente, el Centro de Innovación en Inteligencia Artificial Generativa de AWS colaboró con Patsnap para implementar una función que sugiere automáticamente palabras clave de búsqueda como una exploración de innovación para mejorar la experiencia del usuario en su plataforma.

Patsnap ofrece una plataforma integral a nivel mundial para la búsqueda, análisis y gestión de patentes. Utilizan big data (como un historial de consultas de búsqueda anteriores) para proporcionar muchas herramientas de patentes poderosas pero fáciles de usar. Estas herramientas han permitido a los clientes globales de Patsnap comprender mejor las patentes, rastrear los avances tecnológicos recientes, identificar las 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 puedan mejorar continuamente la experiencia del usuario en la plataforma. Una iniciativa reciente es simplificar la dificultad de construir expresiones de búsqueda mediante el autocompletado de consultas de búsqueda de patentes utilizando modelos de generación de texto de última generación. Patsnap ha entrenado un modelo personalizado de GPT-2 con este propósito. Debido a que no existe una función existente de este tipo en un motor de búsqueda de patentes (según su mejor conocimiento), Patsnap cree que agregar esta función aumentará la fidelidad de los usuarios finales.

• ¿Está cambiando el comportamiento de ChatGPT con el tiempo? Los investigadores evalúan las versiones de marzo de 2023 y junio de 2023 de GPT-3.5 y GPT-4 en cuatro tareas diversas.
• 8 Ejemplos Modernos de Inteligencia Artificial en los Videojuegos
• Un nuevo conjunto de datos de imágenes del Ártico impulsará la investigación en inteligencia artificial

Sin embargo, en sus experimentos recientes, la latencia de inferencia y las consultas por segundo (QPS) de un modelo GPT-2 basado en PyTorch no pudieron alcanzar ciertos umbrales que justifiquen su valor comercial. Para abordar este desafío, los científicos del Centro de Innovación en Inteligencia Artificial Generativa de AWS exploraron diversas soluciones para optimizar el rendimiento de inferencia de GPT-2, lo que resultó en una reducción de la latencia del modelo en un 50% en promedio y una mejora del QPS en un 200%.

Desafíos de inferencia de modelos de lenguaje grandes y enfoques de optimización

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

• La latencia promedio de 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 QPS para realizar un gran número de búsquedas por segundo durante las horas pico de negocio

En esta publicación, discutimos nuestros hallazgos utilizando instancias de Amazon Elastic Compute Cloud (Amazon EC2), que cuentan con instancias basadas en GPU que utilizan NVIDIA TensorRT.

En resumen, utilizamos NVIDIA TensorRT para optimizar la latencia de GPT-2 y lo implementamos en un punto de conexión de Amazon SageMaker para el servicio del modelo, lo que reduce la latencia promedio de 1,172 milisegundos a 531 milisegundos.

En las siguientes secciones, analizamos los detalles técnicos de las soluciones propuestas con fragmentos de código clave y mostramos comparaciones con la situación actual del cliente basadas en métricas clave.

Descripción general del modelo GPT-2

GPT-2 de Open AI es un modelo de lenguaje basado en transformers grande con 1.5 mil millones de parámetros, entrenado en el conjunto de datos WebText, que contiene 8 millones de páginas web. GPT-2 se entrena con un objetivo simple: predecir la siguiente palabra, dadas todas las palabras anteriores dentro de algún texto. La diversidad del conjunto de datos hace que este objetivo simple contenga demostraciones de muchas tareas en diversos dominios. GPT-2 muestra un amplio conjunto de capacidades, incluida la capacidad de generar muestras de texto sintético condicionales de una calidad sin precedentes, donde iniciamos el modelo con una entrada y lo dejamos generar una continuación extensa. En esta situación, lo aprovechamos para generar consultas de búsqueda. A medida que los modelos GPT siguen creciendo más grandes, los costos de inferencia aumentan continuamente, lo que aumenta la necesidad de implementar estos modelos con un costo aceptable.

Lograr baja latencia en instancias de GPU a través de TensorRT

TensorRT es una biblioteca de C++ para inferencia de alto rendimiento en GPUs de NVIDIA y aceleradores de aprendizaje profundo, que admite los principales marcos de aprendizaje profundo como PyTorch y TensorFlow. Estudios anteriores han demostrado una gran mejora en el rendimiento en términos de latencia del modelo. Por lo tanto, es una opción ideal para reducir la latencia del modelo objetivo en GPUs de NVIDIA.

Logramos una reducción significativa en la latencia de inferencia del modelo GPT-2 con un modelo basado en TensorRT en GPUs de NVIDIA. El modelo basado en TensorRT se implementa a través de SageMaker para pruebas de rendimiento. En esta publicación, mostramos los pasos para convertir el modelo original de GPT-2 basado en PyTorch a un modelo basado en TensorRT.

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

1. Analiza tu GPT-2. Hasta la fecha de redacción de este documento, la herramienta de conversión de NVIDIA solo admite la versión del modelo GPT-2 de Hugging Face. Si el modelo GPT-2 actual no es la versión original, debes modificarlo en consecuencia. Se recomienda eliminar el código personalizado de la implementación original de GPT-2 de Hugging Face, lo cual es muy útil para la conversión.
2. Instala los paquetes de Python necesarios. El proceso de conversión primero convierte el modelo basado en PyTorch al modelo basado en ONNX y luego convierte el modelo basado en ONNX al modelo basado en TensorRT. Los siguientes paquetes de Python son necesarios para esta conversión en dos pasos:

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

1. 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 = ('Tu propia ruta para guardar el modelo basado en ONNX') # por ejemplo, ./modelo_fp16.onnx
    gpt2.as_onnx_model(onnx_path, force_overwrite=False)
    return onnx_path, metadata
   
def onnx2trt(onnx_path, metadata):
    trt_path = 'Tu propia ruta para guardar el modelo basado en TensorRT' # por ejemplo, ./modelo_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 vs. TensorRT

En este proyecto, se utiliza JMeter para realizar pruebas de rendimiento. JMeter es un proyecto de Apache que se puede utilizar como herramienta de prueba de carga para analizar y medir el rendimiento de una variedad de servicios. Registramos el QPS y la latencia del modelo original basado en PyTorch y nuestro modelo convertido basado en TensorRT de GPT-2 en una instancia AWS P3.2xlarge. Como mostraremos más adelante en esta publicación, debido a la potente capacidad de aceleración de TensorRT, la latencia de GPT-2 se reduce significativamente. Cuando la concurrencia de las solicitudes es 1, la latencia promedio se ha reducido en 274 milisegundos (2.9 veces más rápido). Desde la perspectiva del QPS, se incrementa a 7 desde 2.4, lo que representa un aumento de aproximadamente 2.9 veces en comparación con el modelo original basado en PyTorch. Además, a medida que aumenta la concurrencia, el QPS sigue aumentando. Esto sugiere costos más bajos con un aumento de latencia aceptable (pero aún mucho más rápido que el modelo original).

La siguiente tabla compara la latencia:

.	Concurrencia	QPS	Latencia Máxima	Latencia Mínima	Latencia Promedio
Versión de PyTorch del cliente (en p3.2xlarge)	1	2.4	632	105	417
2	3.1	919	168	636
3	3.4	1911	222	890
4	3.4	2458	277	1172
Versión de TensorRT de AWS (en p3.2xlarge)	1	7 (+4.6)	275	22	143 (-274 ms)
2	7.2 (+4.1)	274	51	361 (-275 ms)
3	7.3 (+3.9)	548	49	404 (-486 ms)
4	7.5 (+4.1)	765	62	531 (-641 ms)

Despliega 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 de contenedor propio de SageMaker para implementar nuestro modelo. El modo de contenedor propio proporciona una forma flexible de implementar el modelo y puedes construir entornos personalizados en tu propio contenedor Docker. En esta sección, mostramos cómo construir tu propio contenedor, implementar tu propio modelo GPT-2 y probarlo con la API de puntos de conexión de SageMaker.

Construye tu propio contenedor

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

container
├── Dockerfile    # construye nuestro docker basado en este archivo.
├── build.sh      # crea nuestra propia imagen y la envía a Amazon ECR
├── gpt2          # directorio del modelo
├── predictor.py  # función de backend para invocar el modelo
├── serve         # archivo de configuración del servidor web
├── nginx.conf    # archivo de configuración del servidor web
└── wsgi.py       # archivo de configuración del servidor web

Puedes ejecutar sh ./build.sh para construir el contenedor.

Implementa en un punto de conexión de SageMaker

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

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}'
# primero debes cargar tu contenedor en S3
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])
    
# Configuración del punto de conexión
endpoint_config_name = '${Your Endpoint Config Name}'
print('Nombre de la configuración del punto de conexión: ' + 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("ARN de la configuración del punto de conexión: " + create_endpoint_config_response['EndpointConfigArn'])

# Implementa el modelo
endpoint_name = '${Your Endpoint Name}'
print('Nombre del punto de conexión: ' + endpoint_name)
create_endpoint_response = sm_client.create_endpoint(
    EndpointName=endpoint_name,
    EndpointConfigName=endpoint_config_name)
print('ARN del punto de conexión: ' + create_endpoint_response['EndpointArn'])
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp['EndpointStatus']
print("Estado del punto de conexión: " + status)
print('Esperando a que el punto de conexión {} esté en servicio...'.format(endpoint_name))
waiter = sm_client.get_waiter('endpoint_in_service')
waiter.wait(EndpointName=endpoint_name)

Prueba el modelo implementado

Después de implementar correctamente el modelo, puedes probar el punto de conexión a través de la instancia de 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 # Reemplaza con tus propios datos.
                            )
result = json.loads(response['Body'].read().decode())
print(result)

Conclusión

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

Si desea ayuda para acelerar el uso de modelos de GenAI en sus productos y servicios, comuníquese con el AWS Generative AI Innovation Center. El AWS Generative AI Innovation Center puede ayudarlo a hacer realidad sus ideas de manera más rápida y efectiva. Para comenzar con el Generative AI Innovation Center, visite aquí.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!