NLP nas empresas | Técnicas para acelerar modelos de Deep Learning para inferência em produção
Ser capaz de gerar previsões rapidamente a partir de um modelo de Deep Learning em NLP (Natural Language Processing) é uma questão estratégica para todas as empresas. De fato, se mais empresas hoje puderem treinar um modelo de Deep Learning em NLP em seus dados (por exemplo, modelos de QA ou NER) graças às bibliotecas Open Source como Hugging Face, a questão de seu uso na produção levanta a questão de sua latência para inferência, ou seja, sua velocidade de execução para gerar previsões. Na verdade, se o seu modelo de Inteligência Artificial fornecer previsões muito boas, mas demorar muito para produzi-las, ele se tornará inutilizável. Este artigo, bem como os 2 notebooks nos quais se baseia, fornece respostas e códigos a copiar / colar para acelerar gratuitamente e em até 20 vezes seus modelos de Deep Learning em NLP em produção. As bibliotecas de Open Source testadas são PyTorch, ONNX Runtime da Microsoft e TorchScript.
Notebooks no github:
- fast_inference_transformers_on_CPU.ipynb (nbviewer)
- fast_inference_transformers_on_GPU.ipynb (nbviewer)
Sumário
- Inferência rápida na produção? Uma questão estratégica.
- Diferentes maneiras de reduzir o tempo de inferência do seu modelo
- Inferência rápida | Serviços Open Source
— As bibliotecas para acelerar as inferências
>> PyTorch
>> ONNX Runtime
>> TorchScript
— CPU vs GPU | O grande vencedor é ONNX Runtime no GPU
— CPU | ONNX Runtime é o mais rápido
— GPU | ONNX Runtime é o mais rápido - ONNX Runtime para todos os modelos Transformer?
- Inferência rápida | Serviços pagos
— Hugging Face Infinity
— Hugging Face on SageMaker AWS - Referências
Inferência rápida na produção? Uma questão estratégica.
Graças às bibliotecas de Deep Learning em Open Source especializadas em NLP (em particular as da Hugging Face como Transformers) e por meio do aluguel de GPUs no Cloud (GPC, AWS, etc.), todas as empresas agora podem treinar um modelo de NLP em seus dados (por exemplo, um modelo QA: Question-Answering ou NER: Named Entity Recognition) do zero ou ajustar (finetune) um modelo existente (consulte o model hub da HF).
Claro, esse treinamento de modelo requer as habilidades de um profissional em Deep Learning, e pode ser otimizado para economizar tempo com bibliotecas como DeepSpeed, ONNX ou mesmo o serviço AutoNLP da Hugging Face por exemplo. Mas, em comparação com 2018, quando a revolução Transformer começou no NLP (“NLP’s ImageNet moment has arrived” do Sebastian Ruder), essa tarefa de treinamento é relativamente acessível a todas as empresas.
A questão que então surge é como usar esse modelo na produção, ou seja, para ser usado online para gerar previsões. Como as mesmas bibliotecas de Deep Learning no NLP fornecem o código para fazer inferências com os modelos treinados, a questão é mais como diminuir a latência desses modelos, ou seja, o tempo necessário para gerar a previsão após uma solicitação. Na verdade, quando falamos sobre esses modelos de NLP, estamos falando sobre centenas de milhões de parâmetros (até bilhões …).
Esta é uma questão estratégica porque se o seu modelo de Inteligência Artificial fornecer previsões muito boas, mas demorar muito para produzi-las, ele na realidade se tornará inutilizável.
Diferentes maneiras de reduzir o tempo de inferência do seu modelo
(fonte) Aqui estão diferentes maneiras de reduzir o tempo de inferência do seu modelo:
- Model pruning: reduza o número de parâmetros (reduza o número de camadas, a dimensão dos embeddings ou o número de unidades nas camadas ocultas).
- Quantization (Quantização): reduza a memória de armazenamento de parâmetros (em vez de usar 32-bit float (FP32) para parâmetros, use half-precision (FP16) ou mesmo 8-bit integer).
- Exporting: exporte um modelo do Pytorch / Tensorflow nativo para um formato apropriado ou mecanismo de inferência (Torchscript / ONNX / TensorRT…).
- Batching: passa os dados em batch em vez de usar o modelo para dados individuais.
Na maioria dos casos, exportar seu modelo para um formato apropriado com quantização (e possivelmente, inferência em batch) fornecerá resultados muito mais rápidos para uma quantidade mínima de trabalho enquanto o model pruning precisar retreinar seu modelo com técnicas de destilação por exemplo. Vamos nos concentrar nessa abordagem aqui para ver o impacto que ela pode ter no desempenho do nosso modelo.
Inferência rápida | Serviços Open Source
Se houver soluções pagas de alto nível (Hugging Face acaba de anunciar que sua solução Infinity pode gerar uma previsão em 1 ms, ver o parágrafo “Inferência rápida | Serviços pagos” para mais informações), a maioria das empresas já pode se beneficiar das soluções Open Source das bibliotecas de Deep Learning gratuitamente disponíveis.
Testamos 3 bibliotecas com CPU e GPU:
- PyTorch
- ONNX Runtime da Microsoft
- TorchScript
Todos os testes foram realizados:
- em 2 notebooks:
— um para os testes em CPU: fast_inference_transformers_on_CPU.ipynb (nbviewer)
— outro para os testes em GPU: fast_inference_transformers_on_GPU.ipynb (nbviewer)
- a partir de um modelo QA em português baixado do model hub da HF (pierreguillou/bert-base-cased-squad-v1.1-portuguese)
- e na plataforma Google Colab.
Nota: também planejamos atualizar esse post em uma data posterior com os resultados dos testes em outras plataformas do Cloud.
As bibliotecas para acelerar as inferências
Além da biblioteca PyTorch, que é usada nativamente por Hugging Face, testamos as bibliotecas ONNX Runtime e TorchScript.
ONNX (Open Neural Network Exchange, The open standard for machine learning interoperability) is open format for machine learning models. It allows to save your neural network’s computation graph in a framework agnostic way, which might be particulary helpful when deploying deep learning models.
Indeed, businesses might have other requirements (languages, hardware, …) for which the training framework might not be the best suited in inference scenarios. In that context, having a representation of the actual computation graph that can be shared accross various business units and logics across an organization might be a desirable component.
Along with the serialization format, ONNX also provides a runtime library which allows efficient and hardware specific execution of the ONNX graph. This is done through the ONNX Runtime project and already includes collaborations with many hardware vendors to seamlessly deploy models on various platforms.
[ + ] Link: Hugging Face & ONNX Runtime
TorchScript
According to Pytorch’s documentation: “TorchScript is a way to create serializable and optimizable models from PyTorch code”. Pytorch’s two modules JIT and TRACE allow the developer to export their model to be re-used in other programs, such as efficiency-oriented C++ programs.
Hugging Face provided an interface that allows the export of 🤗 Transformers models to TorchScript so that they can be reused in a different environment than a Pytorch-based python program.
[ + ] Link: Hugging Face & TorchScript
CPU vs GPU | O grande vencedor é ONNX Runtime no GPU
Como os resultados de teste de inferência são muito dependentes do hardware usado, é importante mencionar que os 2 notebooks que usamos no Google Colab tinham 2 CPUs Intel (R) Xeon (R) de 2,30 GHz e o que tinha GPU tinha um GPU NVIDIA Tesla K80 (12 GB de RAM). Com hardware mais novo e mais potente, todos os resultados obtidos terão sido melhorados (tempos de latência mais baixos).
Nota: as durações publicadas aqui são apenas aquelas da geração da previsão pelo modelo sem as durações de tokenização do texto e de publicação da previsão. Essas 2 outras durações foram avaliadas nos 2 notebooks por cerca 0.75 e 0.15ms respectivamente, ou seja, 0.9 ms no total).
Aqui estão os resultados de latência de CPU vs GPU:
+----------------------------+------------------+------------------+
| | Latency CPU (ms) | Latency GPU (ms) |
+----------------------------+------------------+------------------+
| PyTorch (without pipeline) | 889.07 | 44.42 |
| ONNX Runtime | 711.50 | 37.54 |
| TorchScript | 849.00 | 74.00 |
+----------------------------+------------------+------------------+Se o custo de compra ou aluguel de um GPU não é um problema para uma empresa, não há hesitação: um GPU permite, em relação à um CPU, dividir a latência de uma inferência por nosso modelo Transformer até quase 20 vezes no caso de uso do ONNX Runtime! (geração da previsão em 38ms)
Enquanto as bibliotecas ONNX Runtime e TorchScript melhoram os resultados em comparação com o uso do PyTorch na CPU e GPU, a biblioteca ONNX Runtime fornece os melhores resultados (a menor latência de uma inferência) em todos os casos (veja os seguinte focos).
CPU | ONNX Runtime é o mais rápido
+--------------------------------------------------------+
| | Latency on CPU (ms) |
+-------------------------------+------------------------+
| PyTorch (without pipeline) | 889.07 |
| ONNX Runtime | 711.50 |
| TorchScript | 849.00 |
+-------------------------------+------------------------+
GPU | ONNX Runtime é o mais rápido
+--------------------------------------------------------+
| | Latency on GPU (ms) |
+-------------------------------+------------------------+
| PyTorch (without pipeline) | 44.42 |
| ONNX Runtime | 37.54 |
| TorchScript | 74.00 |
+-------------------------------+------------------------+
ONNX Runtime para todos os modelos Transformer?
Testamos o ONNX Runtime em um modelo Transformer QA que possui uma arquitetura encoder do tipo BERT. Se usar um modelo Transformer encoder-decoder (seq2seq) como T5 por exemplo, existe uma biblioteca que facilita sua aplicação: fastT5.
Inferência rápida | Serviços pagos
Hugging Face Infinity
Hugging Face on SageMaker AWS
Referências
- (08/2021) Reduce T5 model size by 3X and increase the inference speed up to 5X
- (13/07/2021) Accelerate PyTorch training with torch-ort (training, Microsoft)
- (05/02/2021) An empirical approach to speedup your BERT inference with ONNX/Torchscript
- (18/01/2021) How we sped up transformer inference 100x for 🤗 API customers (Hugging Face)
- (10/11/2020) PyTorch JIT and TorchScript
- (31/08/2020) Faster and smaller quantized NLP with Hugging Face and ONNX Runtime (Microsoft & Hugging Face)
- (19/05/2020) Accelerate your NLP pipelines using Hugging Face Transformers and ONNX Runtime (Microsoft & Hugging Face)
- (03/05/2020) PyTorch: Switching to the GPU
- (25/04/2020) Deploying huggingface‘s BERT to production with pytorch/serve
- (21/04/2020) Deploying PyTorch models for inference at scale using TorchServe
- (05/09/2019) Pruning BERT to accelerate inference
- (08/08/2019) Compressing BERT for faster prediction
- (22/05/2019) ONNX Runtime: a one-stop shop for machine learning inferencing (Microsoft)
- Exporting transformers models (Hugging Face)
- Github ONNX Runtime
Sobre o autor: Pierre Guillou é Head of AI na startup de HealthTech Laudite (Brasil), e consultor de IA no Brasil e na França. Entre em contato com ele por meio de seu perfil no LinkedIn.
