fastT5
1.0.0
Model T5 dapat digunakan untuk beberapa tugas NLP seperti peringkasan, QA, QG, terjemahan, pembuatan teks, dan banyak lagi. Generasi teks berurutan secara alami lambat, dan untuk model T5 yang lebih besar menjadi lebih lambat. FastT5 membuat inferensi model T5 lebih cepat dengan menjalankannya di onnxruntime. dan itu juga mengurangi ukuran model dengan mengukurnya.
Perpustakaan FastT5 memungkinkan Anda untuk mengonversi model T5 pretrained menjadi ONNX, mengukurnya, dan memberikan model sebagai output yang berjalan pada onnxruntime dalam satu baris kode. Anda juga dapat menyesuaikan seluruh proses ini.
Anda dapat menginstal FastT5 dari PYPI:
pip install fastt5Jika Anda ingin membangun dari sumber:
git clone https : // github . com / Ki6an / fastT5
cd fastT5
pip3 install - e . Metode export_and_get_onnx_model() mengekspor model T5 pretrained yang diberikan ke ONNX, mengukurnya dan menjalankannya pada onnxruntime dengan pengaturan default. Model yang dikembalikan dari metode ini mendukung metode generate() dari permukaan pelukan.
Jika Anda tidak ingin mengukur model maka gunakan
quantized=Falsedalam metode ini.
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 )Untuk menjalankan model yang sudah diekspor menggunakan
get_onnx_model()
Anda dapat menyesuaikan seluruh pipa seperti yang ditunjukkan pada contoh kode di bawah ini:
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 )
... Secara default, FastT5 membuat folder models di direktori saat ini dan menyimpan semua model. Anda dapat memberikan jalur khusus untuk folder untuk menyimpan model yang diekspor. Dan untuk menjalankan exported models yang disimpan di jalur folder khusus: Gunakan 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 adalah model seq2seq (encoder-decoder), karena menggunakan decoder berulang kali untuk inferensi, kami tidak dapat secara langsung mengekspor seluruh model ke ONNX. Kita perlu mengekspor enkoder dan decoder secara terpisah.
past_key_valuesberisi keadaan tersembunyi yang telah dikomputasi sebelumnya (kunci dan nilai-nilai dalam blok perhatian diri dan blok silang) yang dapat digunakan untuk mempercepat decoding berurutan.
Model hanya dapat diekspor dengan jumlah input yang konstan. Bertentangan dengan ini, decoder dari langkah pertama tidak mengambil past_key_values dan sisa langkah yang dilakukan decoder. Untuk mengatasi masalah ini, kita dapat membuat dua decoder: satu untuk langkah pertama yang tidak mengambil past_key_values dan satu lagi untuk sisa langkah yang memanfaatkan past_key_values .
Selanjutnya, kami akan mengekspor ketiga model (encoder, decoder, init_decoder). Dan kemudian menghitungnya, mengukur 32bit ke 8bit harus memberikan pengurangan memori 4X. Karena ada decoder tambahan, ukuran model dikurangi sebesar 3x.
Akhirnya, kami akan menjalankan model kuantisasi pada runtime ONNX.
Inferensi sederhana karena model mendukung metode
generate()dari permukaan pelukan.
past_key_values ).generate() .3X menggunakan kuantisasi.5X Speedup Dibandingkan dengan Eksekusi Pytorch untuk Pencarian Serakah dan 3-4X untuk Pencarian Balok. Tolok ukur adalah hasil dari model T5-Base yang diuji pada terjemahan bahasa Inggris ke Prancis.
Grafik berikut menunjukkan latensi model ONNX terkuantisasi vs model pytorch untuk angka balok yang bervariasi dari 1 hingga 9. Latensi yang ditampilkan di sini adalah untuk rata -rata panjang urutan hingga 130.
Peta panas berikut menunjukkan x kali lebih cepat di mana rasio latensi pytorch terhadap model ONNX. Model ONNX mengungguli sebagian besar kasus. Namun, kecepatan model turun untuk panjang urutan yang lebih panjang.
Model terkuantisasi adalah model ringan seperti yang disebutkan sebelumnya, model ini memiliki akurasi yang hampir sama dengan model asli (skor model kuantisasi disebutkan di bagian berikutnya). Model ONNX terkuantisasi memiliki latensi terendah dibandingkan dengan model ONNX & Pytorch.
Model ini mengungguli model Pytorch sebesar 5,7x untuk pencarian serakah rata-rata dan 3-4x untuk pencarian balok.
Catatan: Hasilnya dihasilkan pada
AMD EPYC 7B12, hasil ini dapat bervariasi dari perangkat ke perangkat. Model ONNX biasanya berkinerja baik pada CPU kelas atas dengan lebih banyak inti.
Hasilnya diuji untuk terjemahan bahasa Inggris ke Prancis dengan jumlah pencarian balok 3.
| 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 (kuant) | 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 |
HUB Model Huggingface mendukung model pribadi. Untuk menggunakan versi pribadi yang terlatih dari T5 dengan FastT5 Anda harus pertama-tama telah diautentikasi ke ekosistem Huggingface dengan $ transformers-cli login . Kemudian, saat menggunakan FastT5, ada impor tambahan dan hubungi:
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 Jika Anda tidak dapat menghubungi $ transformers-cli login atau lebih suka menggunakan kunci API Anda, ditemukan di https://huggingface.co/settings/token (atau https://huggingface.co/Organizations/org_name/settings untuk organisasi), Anda dapat meneruskannya sebagai string ke set_auth_token . Hindari Kunci API Hard-Coding Anda ke dalam kode dengan mengatur variabel lingkungan HF_API_KEY=<redacted> , dan kemudian dalam kode:
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 },
}
