fastT5
1.0.0
Os modelos T5 podem ser usados para várias tarefas de PNL, como resumo, QA, QG, tradução, geração de texto e muito mais. A geração de texto seqüencial é naturalmente lenta e, para modelos T5 maiores, fica ainda mais lento. O FASTT5 torna os modelos T5 inferência mais rapidamente, executando -o no OnNxRuntime. e também diminui o tamanho do modelo, quantizando -o.
A biblioteca FASTT5 permite converter um modelo T5 pré -treinado em ONNX, quantizá -lo e fornece o modelo como saída que está em execução em um onNxRuntime em uma única linha de código. Você também pode personalizar todo esse processo.
Você pode instalar o fastt5 a partir do Pypi:
pip install fastt5Se você deseja construir a partir da fonte:
git clone https : // github . com / Ki6an / fastT5
cd fastT5
pip3 install - e . O método export_and_get_onnx_model() exporta o modelo T5 pré -terenciado para Onnx, o quantiza e o executa no OnNxRuntime com as configurações padrão. O modelo retornado deste método suporta o método generate() de Huggingface.
Se você não deseja quantizar o modelo, use
quantized=Falseno método.
from fastT5 import export_and_get_onnx_model
from transformers import AutoTokenizer
model_name = 't5-small'
model = export_and_get_onnx_model ( model_name )
tokenizer = AutoTokenizer . from_pretrained ( model_name )
t_input = "translate English to French: The universe is a dark forest."
token = tokenizer ( t_input , return_tensors = 'pt' )
tokens = model . generate ( input_ids = token [ 'input_ids' ],
attention_mask = token [ 'attention_mask' ],
num_beams = 2 )
output = tokenizer . decode ( tokens . squeeze (), skip_special_tokens = True )
print ( output )Para executar o modelo já exportado, use
get_onnx_model()
Você pode personalizar o pipeline inteiro, como mostrado no exemplo de código abaixo:
from fastT5 import ( OnnxT5 , get_onnx_runtime_sessions ,
generate_onnx_representation , quantize )
from transformers import AutoTokenizer
model_or_model_path = 't5-small'
# Step 1. convert huggingfaces t5 model to onnx
onnx_model_paths = generate_onnx_representation ( model_or_model_path )
# Step 2. (recommended) quantize the converted model for fast inference and to reduce model size.
quant_model_paths = quantize ( onnx_model_paths )
# step 3. setup onnx runtime
model_sessions = get_onnx_runtime_sessions ( quant_model_paths )
# step 4. get the onnx model
model = OnnxT5 ( model_or_model_path , model_sessions )
... Por padrão, o FastT5 cria uma pasta models no diretório atual e armazena todos os modelos. Você pode fornecer um caminho personalizado para uma pasta para armazenar os modelos exportados. E para executar exported models que são armazenados em um caminho de pasta personalizado: use get_onnx_model(onnx_models_path="/path/to/custom/folder/")
from fastT5 import export_and_get_onnx_model , get_onnx_model
model_name = "t5-small"
custom_output_path = "/path/to/custom/folder/"
# 1. stores models to custom_output_path
model = export_and_get_onnx_model ( model_name , custom_output_path )
# 2. run already exported models that are stored in custom path
# model = get_onnx_model(model_name, custom_output_path) O T5 é um modelo seq2seq (Encoder-Decoder), pois usa o decodificador repetidamente para inferência, não podemos exportar diretamente todo o modelo para o ONNX. Precisamos exportar o codificador e o decodificador separadamente.
past_key_valuescontêm estados ocultos pré-computados (chave e valores nos blocos de auto-atendimento e blocos de atendimento cruzado) que podem ser usados para acelerar a decodificação seqüencial.
Os modelos só podem ser exportados com um número constante de entradas. Ao contrário, o decodificador do primeiro passo não leva past_key_values e o restante das etapas decodificadores. Para contornar esse problema, podemos criar dois decodificadores: um para a primeira etapa que não leva past_key_values e outro para o restante das etapas que utilizam o past_key_values .
Em seguida, exportaremos todos os três modelos (codificador, decodificador, init_decoder). E depois quantize -os, quantizar 32bit a 8bit deve dar a redução da memória 4x. Como há um decodificador extra, o tamanho do modelo reduz em 3x.
Por fim, executaremos o modelo quantizado no OnNX Runtime.
A inferência é simples, pois o modelo suporta o método
generate()de Huggingface.
past_key_values ).generate() .3X usando quantização.5X em comparação com a execução do Pytorch para pesquisa gananciosa e 3-4X para pesquisa de feixe. Os benchmarks são o resultado do modelo T5-BASE testado na tradução em inglês para francês.
O gráfico a seguir mostra a latência do modelo OnNX quantizado vs o modelo Pytorch para números de feixe que varia de 1 a 9. As latências mostradas aqui são para a média dos comprimentos de sequência de até 130.
O mapa de calor a seguir mostra o X vezes mais rápido que a razão de latência de pytorch para o modelo ONNX. O modelo ONNX supera a maioria dos casos. No entanto, a velocidade do modelo cai para um comprimento de sequência mais longo.
Os modelos quantizados são modelos leves, conforme mencionado anteriormente, esses modelos têm quase a mesma precisão que o modelo original (as pontuações quantizadas do modelo são mencionadas na próxima seção). Os modelos de ONNX quantizados têm a menor latência em comparação com os modelos ONNX e Pytorch.
O modelo supera o modelo Pytorch em 5.7x para pesquisa gananciosa em média e 3-4x para pesquisa de feixe.
Nota: Os resultados foram gerados no
AMD EPYC 7B12, esses resultados podem variar de dispositivo para dispositivo. Os modelos ONNX geralmente têm um bom desempenho nas CPUs de ponta com mais núcleos.
Os resultados foram testados para tradução em inglês para francês com número de pesquisa de feixe de 3.
| Bleu_4 | METEORO | Rouge_l | |
|---|---|---|---|
| T5-small (quant) | 0,240769 | 0,282342 | 0,468817 |
| T5-Small (Pytorch) | 0,254601 | 0,295172 | 0,492749 |
| T5-BASE (quant) | 0,267606 | 0.306019 | 0,499188 |
| T5-BASE (Pytorch) | 0,268346 | 0.304969 | 0,503306 |
| T5-Large (quant) | 0,286726 | 0,316845 | 0,503585 |
| T5-Large (Pytorch) | 0,294015 | 0,315774 | 0,508677 |
O hub do modelo Huggingface suporta modelos privados. Para usar uma versão privada e pré-treinada do T5 com o FASTT5, você deve primeiro ter autenticado no ecossistema Huggingface com $ transformers-cli login . Então, ao usar o FastT5, há uma importação extra e chamada:
from fastT5 import (
OnnxT5 ,
get_onnx_runtime_sessions ,
generate_onnx_representation ,
quantize ,
set_auth_token )
from transformers import AutoTokenizer
set_auth_token ( True )
# the rest of the code is the same as using a public model Se você não puder ligar para $ transformers-cli login ou preferir usar sua chave de API, encontrada em https://huggingface.co/settings/token (ou https://huggingface.co/organization/org_name/Settings/Token for Organizations), você pode passar por um string a set_auth_token Evite codificar sua chave da API em código, definindo a variável de ambiente HF_API_KEY=<redacted> e, em seguida, em código:
import os
from fastT5 import (
OnnxT5 ,
get_onnx_runtime_sessions ,
generate_onnx_representation ,
quantize ,
set_auth_token )
from transformers import AutoTokenizer
auth_token = os . environ . get ( "HF_API_KEY" )
set_auth_token ( auth_token )
# code proceeds as normal @ article { 2019 t5 ,
author = { Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J . Liu },
title = { Exploring the Limits of Transfer Learning with a Unified Text - to - Text Transformer },
journal = { arXiv e - prints },
year = { 2019 },
archivePrefix = { arXiv },
eprint = { 1910.10683 },
}
