fastT5
1.0.0
T5 -Modelle können für mehrere NLP -Aufgaben wie Zusammenfassung, QA, QG, Übersetzung, Textgenerierung und mehr verwendet werden. Die sequentielle Textgenerierung ist natürlich langsam und für größere T5 -Modelle wird es noch langsamer. Fastt5 lässt die T5 -Modelle schneller durchführen, indem es auf Onnxruntime ausgeführt wird. und es verringert auch die Modellgröße durch Quantisierung.
Mit der Fastt5 -Bibliothek können Sie ein vorgezogenes T5 -Modell in ONNX konvertieren, es quantisieren und das Modell als Ausgabe angeben, das auf einer OnnxRuntime in einer einzelnen Codezeile ausgeführt wird. Sie können diesen ganzen Prozess auch anpassen.
Sie können Fastt5 von PYPI installieren:
pip install fastt5Wenn Sie aus Quelle bauen möchten:
git clone https : // github . com / Ki6an / fastT5
cd fastT5
pip3 install - e . Die Methode export_and_get_onnx_model() exportiert das angegebene vorgeladene T5 -Modell in ONNX, quantisiert es und führt es auf der OnNXruntime mit Standardeinstellungen aus. Das zurückgegebene Modell aus dieser Methode unterstützt die generate() -Methode des Umarmungen.
Wenn Sie das Modell nicht quantisieren möchten, verwenden Sie
quantized=Falsein der Methode.
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 )Um das bereits exportierte Modell auszuführen, verwenden Sie
get_onnx_model()
Sie können die gesamte Pipeline wie im folgenden Code -Beispiel angegeben:
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 )
... Standardmäßig erstellt FastT5 im aktuellen Verzeichnis einen models und speichert alle Modelle. Sie können einen benutzerdefinierten Pfad für einen Ordner bereitstellen, um die exportierten Modelle zu speichern. Und um bereits exported models auszuführen, die in einem benutzerdefinierten Ordnerpfad gespeichert sind: Verwenden Sie 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 ist ein seq2seq -Modell (Encoder-Decoder), da es Decoder wiederholt für Inferenz verwendet, können wir das gesamte Modell nicht direkt in ONNX exportieren. Wir müssen den Encoder und Decoder separat exportieren.
past_key_valuesenthalten vorgefertigte Hidden-State (Schlüssel und Werte in den Selbstbekämpfungsblöcken und Kreuzungsblöcken), mit denen die sequentielle Decodierung beschleunigt werden kann.
Modelle können nur mit einer konstanten Anzahl von Eingängen exportiert werden. Im Gegensatz dazu geht der Decoder des ersten Schritts nicht in past_key_values und den Rest der Schritte Decoder. Um dieses Problem zu umgehen, können wir zwei Decoder erstellen: einen für den ersten Schritt, der nicht past_key_values und eine für den Rest der Schritte, die die past_key_values verwenden, und ein anderer erstellen.
Als nächstes exportieren wir alle drei Modelle (Encoder, Decoder, Init_Decoder). Und dann quantisieren Sie sie und quantisieren Sie 32bit bis 8bit die 4x -Speicherreduktion. Da es einen zusätzlichen Decoder gibt, reduziert sich die Modellgröße um 3x.
Schließlich werden wir das quantisierte Modell auf Onnx -Laufzeit ausführen.
Die Inferenz ist einfach, da das Modell die Umarmungsmethode
generate()unterstützt.
past_key_values ).generate() -Methoden.3X mithilfe der Quantisierung.5X beschleunigt im Vergleich zur Pytorch-Ausführung für gierige Suche und 3-4X für die Strahlsuche. Die Benchmarks sind das Ergebnis des T5-Base-Modells, das auf Englisch bis französischer Übersetzung getestet wurde.
Die folgende Grafik zeigt die Latenz des quantisierten ONNX -Modells gegenüber dem Pytorch -Modell für Strahlnummern, die von 1 bis 9 variieren.
Die folgende Wärmekarte zeigt das x -mal schnellere, das das Verhältnis der Latenz von Pytorch zu ONNX -Modell. Das ONNX -Modell übertrifft die meisten Fälle. Die Geschwindigkeit des Modells fällt jedoch für eine längere Sequenzlänge ab.
Quantisierte Modelle sind leichte Modelle, wie bereits erwähnt. Diese Modelle haben fast die gleiche Genauigkeit wie das ursprüngliche Modell (quantisierte Modellwerte werden im nächsten Abschnitt erwähnt). Quantisierte ONNX -Modelle haben im Vergleich zu ONNX- und Pytorch -Modellen die niedrigste Latenz.
Das Modell übertrifft das Pytorch-Modell durchschnittlich 5,7x für die gierige Suche im Durchschnitt und 3-4x für die Strahlsuche.
Hinweis: Die Ergebnisse wurden auf
AMD EPYC 7B12generiert. Diese Ergebnisse können von Gerät zu Gerät variieren. Die ONNX-Modelle funktionieren normalerweise bei High-End-CPUs mit mehr Kernen gut.
Die Ergebnisse wurden auf Englisch mit französischer Übersetzung mit Strahlsuchnummer von 3 getestet.
| Bleu_4 | METEOR | 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 |
Das Huggingface -Modell -Hub unterstützt private Modelle. Um eine private, vorgebildete Version von T5 mit FASTT5 zu verwenden, müssen Sie sich zunächst in das Huggingface-Ökosystem mit $ transformers-cli login authentifiziert haben. Bei Verwendung von Fastt5 gibt es dann einen zusätzlichen Import und Anruf:
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 Wenn Sie $ transformers-cli login nicht aufrufen oder Ihre API set_auth_token Taste bevorzugen, finden Sie unter https://huggingface.co/Setings/token (oder https://huggingface.co/organisationen/ORG_NAME/Setings/Token für Organisationen). Vermeiden Sie Ihren API-Schlüssel in den Code, indem Sie die Umgebungsvariable HF_API_KEY=<redacted> und dann in Code einstellen:
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 },
}
