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

Es probable que 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 expresiones bastante comunes que usamos en la vida diaria, en algunos casos los términos de búsqueda son muy específicos del escenario. La búsqueda 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 una exploración de innovación para mejorar las experiencias de los usuarios en su plataforma.

Patsnap proporciona una plataforma integral global para la búsqueda, 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 comprender mejor 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 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 había entrenado un modelo GPT-2 personalizado para tal fin. Debido a que no existe tal función en un motor de búsqueda de patentes (hasta donde saben), Patsnap cree que agregar esta función aumentará la permanencia del usuario final.

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 pueden justificar su valor comercial. Para enfrentar este desafío, los científicos del Centro de innovación de IA generativa de AWS exploraron una variedad de 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 grande y enfoques de optimización

En general, la aplicación de un modelo tan grande en un entorno de producción del mundo real no es trivial. El costo de computación prohibitivo y la latencia de GPT-2 basado en PyTorch dificultaron su adopción generalizada desde la perspectiva de las operaciones comerciales. En este proyecto, nuestro objetivo es mejorar significativamente la latencia con costos de cómputo 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 QPS para realizar una gran cantidad de búsquedas por segundo durante las horas pico de trabajo

En esta publicación, discutimos nuestros hallazgos usando Nube informática elástica de Amazon (Amazon EC2), con instancias basadas en GPU que utilizan NVIDIA TensorRT.

En un breve resumen, usamos NVIDIA TensorRT para optimizar la latencia de GPT-2 e implementarlo en un Amazon SageMaker punto final para el servicio de modelos, lo que reduce la latencia promedio de 1,172 milisegundos a 531 milisegundos

En las siguientes secciones, repasamos 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.

Descripción general del modelo GPT-2

El GPT-2 de Open AI es un gran transformadorbasado en un modelo de lenguaje con 1.5 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 dentro de un texto. La diversidad del conjunto de datos hace que este simple objetivo contenga demostraciones naturales de muchas tareas en diversos dominios. GPT-2 muestra un amplio conjunto de capacidades, incluida la capacidad de generar muestras de texto sintético condicional de una calidad sin precedentes, donde preparamos el modelo con una entrada y dejamos que genere una continuación prolongada. En esta situación, la explotamos para generar consultas de búsqueda. A medida que los modelos GPT siguen creciendo, los costos de inferencia aumentan continuamente, lo que aumenta la necesidad de implementar estos modelos con 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, que admite 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 las pruebas de rendimiento. En esta publicación, mostramos los pasos para convertir el modelo GPT-2 original basado en PyTorch en un modelo basado en TensorRT.

Convertir el GPT-2 basado en PyTorch al modelo basado en TensorRT no es difícil a través de la herramienta oficial proporcionada por NVIDIA. Además, con conversiones tan sencillas, no se ha observado 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 del modelo GPT-2 de Hugging Face. Si el modelo GPT-2 actual no es la versión original, debe modificarlo en consecuencia. Se recomienda quitar 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 y luego convierte el modelo basado en ONNX al modelo basado en TensorRT. Se necesitan 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 vs. TensorRT

JMeter se utiliza para la evaluación comparativa del rendimiento en este proyecto. 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 GPT-2 basado en TensorRT convertido en una instancia AWS P3.2xlarge. Como mostramos más adelante en esta publicación, debido a la poderosa capacidad de aceleración de TensorRT, la latencia de GPT-2 se reduce significativamente. Cuando la concurrencia de solicitudes es 1, la latencia promedio se ha reducido en 274 milisegundos (2.9 veces más rápido). Desde la perspectiva de QPS, se aumentó a 7 desde 2.4, lo que representa un aumento de alrededor de 2.9 veces en comparación con el modelo original basado en PyTorch. Además, a medida que aumenta la concurrencia, QPS sigue aumentando. Esto sugiere costos más bajos con un aumento de latencia aceptable (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 de TensorRT relativamente reciente, por lo que elegimos la trae tu propio contenedor (BYOC) de SageMaker para implementar nuestro modelo. El modo BYOC proporciona una forma flexible de implementar el modelo y puede crear entornos personalizados en su propio contenedor Docker. En esta sección, mostramos cómo crear su propio contenedor, implementar su propio modelo GPT-2 y realizar pruebas con la API de punto final 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 implementar el modelo y la API de inferencia. serve, nginx.confy wsgi.py proporcionar la configuración para el 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

Una vez que haya creado un contenedor para ejecutar el 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 esta publicación, describimos cómo habilitar la inferencia GPT-2 de baja latencia en SageMaker para crear valor comercial. Específicamente, con el soporte de 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 desea 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 efectiva. Para comenzar con el Centro de innovación de IA generativa, visite esta página.

Acerca de los autores

hao huang es científico aplicado en el Centro de innovación de IA generativa de AWS. Se especializa en visión artificial (CV) y modelo de lenguaje visual (VLM). Recientemente, ha desarrollado un gran interés en las tecnologías de IA generativa y ya ha colaborado con clientes para aplicar estas tecnologías de vanguardia a sus negocios. También es revisor de conferencias de IA como ICCV y AAAI.

Bai Zilong es ingeniero senior de procesamiento de 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.

Yuanjun Xiao es arquitecto de soluciones en AWS. Es responsable de la consultoría y el diseño de la arquitectura de AWS. También le apasiona crear soluciones analíticas y de inteligencia artificial.

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

Guang yang 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 última generación.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Automoción / vehículos eléctricos, Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• Desplazamientos de bloque. Modernización de la propiedad de compensaciones ambientales. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/how-patsnap-used-gpt-2-inference-on-amazon-sagemaker-with-low-latency-and-cost/