fastT5
1.0.0
Los modelos T5 se pueden usar para varias tareas de PNL, como resumen, QA, QG, traducción, generación de texto y más. La generación de texto secuencial es naturalmente lenta, y para los modelos T5 más grandes se vuelve aún más lenta. FastT5 hace que los modelos T5 inferen más rápido ejecutándola en Onnxruntime. y también disminuye el tamaño del modelo cuantificándolo.
La biblioteca FASTT5 le permite convertir un modelo T5 previamente pracricado a ONNX, cuantifica y le da al modelo como salida que se ejecuta en un Onnxruntime en una sola línea de código. También puede personalizar todo este proceso.
Puede instalar FastT5 desde Pypi:
pip install fastt5Si quieres construir desde la fuente:
git clone https : // github . com / Ki6an / fastT5
cd fastT5
pip3 install - e . El método export_and_get_onnx_model() exporta el modelo T5 previamente practicado a ONNX, lo cuantifica y lo ejecuta en el Onnxruntime con la configuración predeterminada. El modelo devuelto de este método admite el método generate() de Huggingface.
Si no desea cuantificar el modelo, use
quantized=Falseen el 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 ejecutar el modelo ya exportado, use
get_onnx_model()
Puede personalizar toda la tubería como se muestra en el siguiente ejemplo del código:
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 defecto, FastT5 crea una carpeta models en el directorio actual y almacena todos los modelos. Puede proporcionar una ruta personalizada para una carpeta para almacenar los modelos exportados. Y para ejecutar exported models que se almacenan en una ruta de carpeta personalizada: 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) T5 es un modelo seq2seq (codificador del codificador), ya que usa decodificador repetidamente para inferencia, no podemos exportar directamente todo el modelo a ONNX. Necesitamos exportar el codificador y el decodificador por separado.
past_key_valuescontiene estados ocultos precomputados (clave y valores en los bloques de autoatención y bloques de atención cruzada) que pueden usarse para acelerar la decodificación secuencial.
Los modelos solo se pueden exportar con un número constante de entradas. Al contrario de esto, el decodificador del primer paso no toma past_key_values y el resto de los pasos que hacen los decodificadores. Para evitar este problema, podemos crear dos decodificadores: uno para el primer paso que no toma past_key_values y otro para el resto de los pasos que utilizan past_key_values .
A continuación, exportaremos los tres modelos (codificador, decodificador, init_decoder). Y luego cuantificarlos, cuantificar 32bit a 8bit debería dar la reducción de la memoria 4x. Dado que hay un decodificador adicional, el tamaño del modelo se reduce en 3x.
Finalmente, ejecutaremos el modelo cuantificado en ONNX Runtime.
La inferencia es simple ya que el modelo admite el método
generate()de Huggingface.
past_key_values ).generate() .3X usando cuantización.5X aceleración en comparación con la ejecución de Pytorch para búsqueda codiciosa y 3-4X para la búsqueda del haz. Los puntos de referencia son el resultado del modelo de base T5 probado en traducción al inglés a francés.
El siguiente gráfico muestra la latencia del modelo ONNX cuantificado frente al modelo Pytorch para números de haz que varía de 1 a 9. Las latencias que se muestran aquí son para la media de longitudes de secuencia de hasta 130.
El siguiente mapa de calor muestra el x veces más rápido, que la relación de latencia de pytorch al modelo ONNX. El modelo ONNX supera a la mayoría de los casos. Sin embargo, la velocidad del modelo cae para una longitud de secuencia más larga.
Los modelos cuantificados son modelos livianos como se mencionó anteriormente, estos modelos tienen casi la misma precisión que el modelo original (las puntuaciones del modelo cuantificada se mencionan en la siguiente sección). Los modelos ONX cuantificados tienen la latencia más baja en comparación con los modelos ONNX y Pytorch.
El modelo supera al modelo Pytorch en 5.7x para la búsqueda codiciosa en promedio y 3-4X para la búsqueda del haz.
Nota: Los resultados se generaron en
AMD EPYC 7B12, estos resultados pueden variar de un dispositivo a otro. Los modelos ONNX generalmente funcionan bien en CPU de alta gama con más núcleos.
Los resultados se probaron para la traducción al inglés a la traducción al francés con el número de búsqueda de haz de 3.
| Bleu_4 | METEORITO | Rouge_L | |
|---|---|---|---|
| T5-Small (Quant) | 0.240769 | 0.282342 | 0.468817 |
| T5-Small (Pytorch) | 0.254601 | 0.295172 | 0.492749 |
| base T5 (cuant) | 0.267606 | 0.306019 | 0.499188 |
| Base T5 (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 |
El Hub Model Hub de Huggingface admite modelos privados. Para usar una versión privada de T5 con FASTT5, primero debe haberse autenticado en el ecosistema Huggingface con $ transformers-cli login . Luego, cuando se usa FastT5, hay una importación adicional y una llamada:
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 no puede llamar $ transformers-cli login o prefiere usar su clave API, encontrada en https://huggingface.co/settings/token (o https://huggingface.co/organizations/org_name/settings/token para organizaciones), puede aprobarlo como una cadena para set_auth_token . Evite codificar su clave API en el código configurando la variable de entorno HF_API_KEY=<redacted> , y luego en el 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 },
}
