Esta postagem de blog foi escrita em coautoria e inclui uma introdução de Zilong Bai, engenheiro sênior de processamento de linguagem natural da Patsnap.

Você provavelmente está familiarizado com o recurso de sugestão de preenchimento automático ao pesquisar algo no Google ou na Amazon. Embora os termos de pesquisa nesses cenários sejam palavras-chave ou expressões bastante comuns que usamos no dia a dia, em alguns casos os termos de pesquisa são muito específicos para o cenário. A busca de patentes é uma delas. Recentemente, o AWS Generative AI Innovation Center colaborou com Patsnap para implementar um recurso para sugerir automaticamente palavras-chave de pesquisa como uma exploração de inovação para melhorar as experiências do usuário em sua plataforma.

A Patsnap fornece uma plataforma global completa para pesquisa, análise e gerenciamento de patentes. Eles usam big data (como um histórico de consultas de pesquisa anteriores) para fornecer muitas ferramentas de patentes poderosas e fáceis de usar. Essas ferramentas permitiram que os clientes globais da Patsnap entendessem melhor as patentes, acompanhassem avanços tecnológicos recentes, identificassem tendências de inovação e analisassem concorrentes em tempo real.

Ao mesmo tempo, a Patsnap está adotando o poder do aprendizado de máquina (ML) para desenvolver recursos que podem melhorar continuamente as experiências do usuário na plataforma. Uma iniciativa recente é simplificar a dificuldade de construir expressões de pesquisa preenchendo automaticamente as consultas de pesquisa de patentes usando modelos de geração de texto de última geração. Patsnap treinou um modelo GPT-2 customizado para tal propósito. Como não existe tal recurso em um mecanismo de busca de patentes (até onde eles sabem), Patsnap acredita que adicionar esse recurso aumentará a aderência do usuário final.

No entanto, em seus experimentos recentes, a latência de inferência e as consultas por segundo (QPS) de um modelo GPT-2 baseado em PyTorch não conseguiram atender a certos limites que podem justificar seu valor comercial. Para enfrentar esse desafio, os cientistas do AWS Generative AI Innovation Center exploraram uma variedade de soluções para otimizar o desempenho de inferência GPT-2, resultando na redução da latência do modelo em 50% em média e melhorando o QPS em 200%.

Grandes desafios de inferência de modelo de linguagem e abordagens de otimização

Em geral, aplicar um modelo tão grande em um ambiente de produção do mundo real não é trivial. O custo de computação proibitivo e a latência do GPT-2 baseado em PyTorch dificultaram sua ampla adoção do ponto de vista da operação comercial. Neste projeto, nosso objetivo é melhorar significativamente a latência com custos computacionais razoáveis. Especificamente, o Patsnap requer o seguinte:

• A latência média da inferência do modelo para gerar expressões de pesquisa precisa ser controlada em 600 milissegundos em cenários de pesquisa em tempo real
• O modelo requer alta taxa de transferência e QPS para fazer um grande número de pesquisas por segundo durante o horário comercial de pico

Neste post, discutimos nossas descobertas usando Amazon Elastic Compute Nuvem (Amazon EC2), apresentando instâncias baseadas em GPU usando NVIDIA TensorRT.

Em um breve resumo, usamos o NVIDIA TensorRT para otimizar a latência do GPT-2 e implantá-lo em um Amazon Sage Maker endpoint para veiculação de modelo, que reduz a latência média de 1,172 milissegundos para 531 milissegundos

Nas seções a seguir, examinamos os detalhes técnicos das soluções propostas com trechos de código-chave e mostramos comparações com o status quo do cliente com base em métricas-chave.

Visão geral do modelo GPT-2

O GPT-2 da Open AI é um grande transformadormodelo de linguagem baseado em 1.5 bilhão de parâmetros, treinado no conjunto de dados WebText, contendo 8 milhões de páginas da web. O GPT-2 é treinado com um objetivo simples: prever a próxima palavra, dadas todas as palavras anteriores dentro de algum texto. A diversidade do conjunto de dados faz com que esse objetivo simples contenha demonstrações naturais de muitas tarefas em diversos domínios. O GPT-2 exibe um amplo conjunto de recursos, incluindo a capacidade de gerar amostras de texto sintético condicional de qualidade sem precedentes, onde preparamos o modelo com uma entrada e deixamos que ele gere uma longa continuação. Nessa situação, nós o exploramos para gerar consultas de pesquisa. Como os modelos GPT continuam crescendo, os custos de inferência aumentam continuamente, o que aumenta a necessidade de implantar esses modelos com custo aceitável.

Obtenha baixa latência em instâncias de GPU via TensorRT

TensorRT é uma biblioteca C++ para inferência de alto desempenho em GPUs NVIDIA e aceleradores de aprendizado profundo, compatível com as principais estruturas de aprendizado profundo, como PyTorch e TensorFlow. Estudos anteriores mostraram grande melhoria de desempenho em termos de latência do modelo. Portanto, é uma escolha ideal para reduzirmos a latência do modelo de destino nas GPUs NVIDIA.

Conseguimos uma redução significativa na latência de inferência do modelo GPT-2 com um modelo baseado em TensorRT em GPUs NVIDIA. O modelo baseado em TensorRT é implantado via SageMaker para testes de desempenho. Nesta postagem, mostramos as etapas para converter o modelo GPT-2 baseado em PyTorch original em um modelo baseado em TensorRT.

Converter o GPT-2 baseado em PyTorch para o modelo baseado em TensorRT não é difícil por meio de a ferramenta oficial fornecido pela NVIDIA. Além disso, com tais conversões diretas, nenhuma degradação óbvia da precisão do modelo foi observada. Em geral, existem três etapas a serem seguidas:

1. Analise seu GPT-2. Até o momento, a ferramenta de conversão da NVIDIA suporta apenas a versão Hugging Face do modelo GPT-2. Se o modelo GPT-2 atual não for a versão original, você precisará modificá-lo de acordo. É recomendável remover o código personalizado da implementação GPT-2 original do Hugging Face, que é muito útil para a conversão.
2. Instale os pacotes Python necessários. O processo de conversão primeiro converte o modelo baseado em PyTorch para o modelo ONNX e, em seguida, converte o modelo baseado em ONNX para o modelo baseado em TensorRT. Os seguintes pacotes Python são necessários para esta conversão em duas etapas:

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

3. Converta seu modelo. O código a seguir contém as funções para a conversão em duas etapas:

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)

Comparação de latência: PyTorch vs. TensorRT

JMeter é usado para benchmarking de desempenho neste projeto. JMeter é um projeto Apache que pode ser usado como uma ferramenta de teste de carga para analisar e medir o desempenho de uma variedade de serviços. Registramos o QPS e a latência do modelo original baseado em PyTorch e nosso modelo GPT-2 baseado em TensorRT convertido em uma instância AWS P3.2xlarge. Como mostraremos mais adiante neste post, devido à poderosa capacidade de aceleração do TensorRT, a latência do GPT-2 é significativamente reduzida. Quando a simultaneidade da solicitação é 1, a latência média foi reduzida em 274 milissegundos (2.9 vezes mais rápido). Do ponto de vista do QPS, aumentou para 7 de 2.4, o que representa um aumento de cerca de 2.9 vezes em comparação com o modelo original baseado em PyTorch. Além disso, à medida que a simultaneidade aumenta, o QPS continua aumentando. Isso sugere custos menores com aumento de latência aceitável (mas ainda muito mais rápido que o modelo original).

A tabela a seguir compara a latência:

Implante GPT-2 baseado em TensorRT com SageMaker e um contêiner personalizado

O GPT-2 baseado em TensorRT requer uma versão relativamente recente do TensorRT, então escolhemos o traga seu próprio recipiente (BYOC) do SageMaker para implantar nosso modelo. O modo BYOC fornece uma maneira flexível de implantar o modelo e você pode criar ambientes personalizados em seu próprio contêiner do Docker. Nesta seção, mostramos como criar seu próprio contêiner, implantar seu próprio modelo GPT-2 e testar com a API de endpoint do SageMaker.

Crie seu próprio contêiner

O diretório de arquivos do contêiner é apresentado no código a seguir. Especificamente, Dockerfile e build.sh são usados ​​para construir o contêiner do Docker. gpt2 e predictor.py implementar o modelo e a API de inferência. serve, nginx.conf e wsgi.py fornecer a configuração para o 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

Você pode correr sh ./build.sh para construir o recipiente.

Implantar em um endpoint do SageMaker

Depois de criar um contêiner para executar o GPT-2 baseado em TensorRT, você pode habilitar a inferência em tempo real por meio de um endpoint do SageMaker. Use os trechos de código a seguir para criar o endpoint e implantar o modelo no endpoint usando as APIs do SageMaker correspondentes:

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)

Testar o modelo implantado

Após a implantação bem-sucedida do modelo, você pode testar o endpoint por meio da instância de notebook SageMaker com o seguinte 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)

Conclusão

Nesta postagem, descrevemos como habilitar a inferência GPT-2 de baixa latência no SageMaker para criar valor comercial. Especificamente, com o suporte do NVIDIA TensorRT, podemos atingir uma aceleração de 2.9 vezes nas instâncias de GPU NVIDIA com o SageMaker para um modelo GPT-2 personalizado.

Se você quiser ajuda para acelerar o uso de modelos GenAI em seus produtos e serviços, entre em contato com o AWS Generative AI Innovation Center. O AWS Generative AI Innovation Center pode ajudá-lo a transformar suas ideias em realidade com mais rapidez e eficiência. Para começar com o Generative AI Innovation Center, visite SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

Sobre os autores

Hao Huang é um cientista aplicado no AWS Generative AI Innovation Center. Ele é especialista em Visão Computacional (CV) e Modelo de Linguagem Visual (VLM). Recentemente, ele desenvolveu um forte interesse em tecnologias de IA generativas e já colaborou com clientes para aplicar essas tecnologias de ponta em seus negócios. Ele também é revisor de conferências de IA, como ICCV e AAAI.

Zilongbai é engenheiro sênior de processamento de linguagem natural na Patsnap. Ele é apaixonado por pesquisa e trabalho de prova de conceito em técnicas de ponta para modelos de linguagem generativa.

Yuanjun Xiao é arquiteto de soluções na AWS. Ele é responsável pela consultoria e design de arquitetura da AWS. Ele também é apaixonado por construir soluções analíticas e de IA.

XuefeiZhang é um cientista aplicado no AWS Generative AI Innovation Center, trabalha nas áreas de NLP e AGI para resolver problemas do setor com os clientes.

guang yang é um cientista aplicado sênior no AWS Generative AI Innovation Center, onde trabalha com clientes em vários setores e aplica soluções criativas de problemas para gerar valor para os clientes com soluções de ML/IA de última geração.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Automotivo / EVs, Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• BlockOffsets. Modernizando a Propriedade de Compensação Ambiental. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/how-patsnap-used-gpt-2-inference-on-amazon-sagemaker-with-low-latency-and-cost/