fastT5
1.0.0
Les modèles T5 peuvent être utilisés pour plusieurs tâches NLP telles que le résumé, la QA, le QG, la traduction, la génération de texte, etc. La génération de texte séquentielle est naturellement lente et pour les modèles T5 plus grands, il devient encore plus lent. FastT5 rend les modèles T5 plus rapidement en l'exécutant sur onnxruntime. Et il diminue également la taille du modèle en le quantifiant.
La bibliothèque FastT5 vous permet de convertir un modèle T5 pré-entraîné en ONNX, le quantifie et donne le modèle comme sortie qui fonctionne sur un onnxruntime dans une seule ligne de code. Vous pouvez également personnaliser tout ce processus.
Vous pouvez installer FastT5 depuis PYPI:
pip install fastt5Si vous souhaitez construire à partir de la source:
git clone https : // github . com / Ki6an / fastT5
cd fastT5
pip3 install - e . La méthode export_and_get_onnx_model() exporte le modèle T5 prétrainé donné à onnx, le quantifie et l'exécute sur le onnxruntime avec des paramètres par défaut. Le modèle renvoyé de cette méthode prend en charge la méthode generate() de câlins.
Si vous ne souhaitez pas quantifier le modèle, utilisez
quantized=Falsedans la méthode.
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 )Pour exécuter le modèle déjà exporté, utilisez
get_onnx_model()
Vous pouvez personnaliser l'intégralité du pipeline comme indiqué dans l'exemple de code ci-dessous:
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 )
... Par défaut, FastT5 crée un dossier models dans le répertoire actuel et stocke tous les modèles. Vous pouvez fournir un chemin personnalisé pour un dossier pour stocker les modèles exportés. Et pour exécuter exported models qui sont stockés dans un chemin de dossier personnalisé: utilisez 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) T5 est un modèle seq2seq (coder-décodeur), car il utilise le décodeur à plusieurs reprises pour l'inférence, nous ne pouvons pas exporter directement tout le modèle vers ONNX. Nous devons exporter séparément l'encodeur et le décodeur.
past_key_valuescontiennent des états cachés pré-calculés (clé et valeurs dans les blocs d'auto-attention et blocs de transtention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel.
Les modèles ne peuvent être exportés qu'avec un nombre constant d'entrées. Contrairement à cela, le décodeur de la première étape ne prend pas past_key_values et le reste des étapes que les décodeurs font. Pour contourner ce problème, nous pouvons créer deux décodeurs: un pour la première étape qui ne prend pas past_key_values et un autre pour le reste des étapes qui utilisent les past_key_values .
Ensuite, nous exporterons les trois modèles (Encodeur, Decoder, INIT_DECODER). Puis les quantifier, en quantifiant 32bit à 8bit devrait donner la réduction de la mémoire 4x. Puisqu'il y a un décodeur supplémentaire, la taille du modèle réduit de 3x.
Enfin, nous exécuterons le modèle quantifié sur ONNX Runtime.
L'inférence est simple car le modèle prend en charge la méthode
generate()de câlins.
past_key_values ).generate() .3X en utilisant la quantification.5X accélération par rapport à l'exécution de Pytorch pour la recherche gourmand et 3-4X pour la recherche de faisceau. Les repères sont le résultat du modèle de base T5 testé sur la traduction de l'anglais à la française.
Le graphique suivant montre la latence du modèle ONNX quantifié par rapport au modèle Pytorch pour les nombres de faisceaux variant de 1 à 9. Les latences montrées ici sont pour la moyenne des longueurs de séquence jusqu'à 130.
La carte thermique suivante montre plus rapidement les fois où le rapport de latence du modèle Pytorch au modèle ONNX. Le modèle ONNX surpasse la plupart des cas. Cependant, la vitesse du modèle baisse pour une longueur de séquence plus longue.
Les modèles quantifiés sont des modèles légers comme mentionné précédemment, ces modèles ont presque la même précision que le modèle d'origine (les scores de modèle quantifiés sont mentionnés dans la section suivante). Les modèles ONNX quantifiés ont la latence la plus faible par rapport aux modèles ONNX et Pytorch.
Le modèle surpasse le modèle Pytorch de 5,7x pour la recherche gourmand en moyenne et 3-4x pour la recherche de faisceau.
Remarque: Les résultats ont été générés sur
AMD EPYC 7B12, ces résultats peuvent varier d'un appareil à l'autre. Les modèles ONNX fonctionnent généralement bien sur des CPU haut de gamme avec plus de cœurs.
Les résultats ont été testés pour la traduction de l'anglais à français avec un numéro de recherche de faisceau de 3.
| Bleu_4 | MÉTÉORE | 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-grand (quant) | 0.286726 | 0,316845 | 0,503585 |
| T5-grand (pytorch) | 0.294015 | 0,315774 | 0,508677 |
Le Huggingface Model Hub prend en charge les modèles privés. Pour utiliser une version privée pré-formée de T5 avec FastT5, vous devez d'abord avoir authentifié l'écosystème HuggingFace avec $ transformers-cli login . Ensuite, lorsque vous utilisez FastT5, il y a une importation supplémentaire et un appel:
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 Si vous n'êtes pas en mesure d'appeler $ transformers-cli login ou préférez utiliser votre clé API, trouvée sur https://huggingface.co/settings/token (ou https://huggingface.co/organizations/org_name/settings/Token pour les organisations), vous pouvez passer cela en tant que chaîne à set_auth_token . Évitez le codage dur de votre clé API en code en définissant la variable d'environnement HF_API_KEY=<redacted> , puis dans le code:
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 },
}
