fastT5

• ติดตั้ง
• การใช้งาน
• รายละเอียด
• ฟังก์ชั่น
• เกณฑ์มาตรฐาน
  • รุ่น ONNX
  • รูปแบบ ONNX ที่เป็นปริมาณ
• คะแนนแบบจำลองเชิงปริมาณ
• การปรับปรุงเพิ่มเติม
• ใบอนุญาต
• รับความช่วยเหลือ
• กิตติกรรมประกาศ

รุ่น T5 สามารถใช้สำหรับงาน NLP หลายอย่างเช่นการสรุป, QA, QG, การแปล, การสร้างข้อความและอื่น ๆ การสร้างข้อความตามลำดับนั้นช้าตามธรรมชาติและสำหรับรุ่น T5 ที่ใหญ่ขึ้นมันจะช้าลง FASTT5 ทำให้การอนุมานแบบจำลอง T5 เร็วขึ้นโดยใช้งานบน OnnxRuntime และยังลดขนาดของแบบจำลองโดยการหาปริมาณ

ไลบรารี FASTT5 ช่วยให้คุณสามารถแปลงรุ่น T5 ที่ผ่านการฝึกอบรมเป็น ONNX ปริมาณและให้แบบจำลองเป็นเอาต์พุตที่ทำงานบน ONNXRuntime ในรหัสบรรทัดเดียว คุณยังสามารถปรับแต่งกระบวนการทั้งหมดนี้

---

ติดตั้ง

คุณสามารถติดตั้ง FASTT5 จาก PYPI:

 pip install fastt5

หากคุณต้องการสร้างจากแหล่งที่มา:

 git clone https : // github . com / Ki6an / fastT5
cd fastT5
pip3 install - e .

การใช้งาน

เมธอด export_and_get_onnx_model() ส่งออกโมเดล T5 pretrained ที่กำหนดไปยัง ONNX คำนวณปริมาณและรันบน onnxRuntime ด้วยการตั้งค่าเริ่มต้น โมเดลที่ส่งคืนจากวิธีนี้รองรับวิธี generate() ของ HuggingFace

หากคุณไม่ต้องการหาปริมาณโมเดลให้ใช้ quantized=False ในวิธีการ

 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 )

ในการเรียกใช้โมเดลที่ส่งออกแล้วให้ใช้ get_onnx_model()

คุณสามารถปรับแต่งท่อทั้งหมดตามที่แสดงในตัวอย่างรหัสด้านล่าง:

 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 )

                      ...

เส้นทางเอาต์พุตแบบกำหนดเอง

โดยค่าเริ่มต้น FASTT5 จะสร้างโฟลเดอร์ models ในไดเรกทอรีปัจจุบันและจัดเก็บทุกรุ่น คุณสามารถให้เส้นทางที่กำหนดเองสำหรับโฟลเดอร์เพื่อจัดเก็บรุ่นที่ส่งออก และในการรัน exported models แล้วที่เก็บไว้ในเส้นทางโฟลเดอร์ที่กำหนดเอง: ใช้ 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 เป็นโมเดล seq2seq (ตัวเข้ารหัส-ตัวพิมพ์ใหญ่) เนื่องจากใช้ตัวถอดรหัสซ้ำ ๆ สำหรับการอนุมานเราไม่สามารถส่งออกโมเดลทั้งหมดไปยัง ONNX ได้โดยตรง เราจำเป็นต้องส่งออกเครื่องเข้ารหัสและตัวถอดรหัสแยกกัน

past_key_values มีสถานะที่ซ่อนไว้ล่วงหน้า (คีย์และค่าในบล็อกการใส่ใจในตนเองและบล็อกข้ามความสนใจ) ที่สามารถใช้เพื่อเพิ่มความเร็วในการถอดรหัสตามลำดับ

แบบจำลองสามารถส่งออกด้วยจำนวนอินพุตคงที่เท่านั้น ตรงกันข้ามกับสิ่งนี้ตัวถอดรหัสของขั้นตอนแรกไม่ได้ใช้ past_key_values ​​และส่วนที่เหลือของตัวถอดรหัสทำ ในการแก้ไขปัญหานี้เราสามารถสร้างตัวถอดรหัสสองตัว: หนึ่งในขั้นตอนแรกที่ไม่ใช้ past_key_values ​​และอีกขั้นสำหรับขั้นตอนที่เหลือที่ใช้ประโยชน์ past_key_values

ต่อไปเราจะส่งออกทั้งสามรุ่น (Encoder, Decoder, Init_decoder) จากนั้นจึงหาปริมาณพวกเขาการหาปริมาณ 32bit ถึง 8bit ควรให้การลดหน่วยความจำ 4x เนื่องจากมีตัวถอดรหัสเพิ่มเติมขนาดของรุ่นจึงลดลง 3x

ในที่สุดเราจะเรียกใช้โมเดลเชิงปริมาณบนรันไทม์ ONNX

การอนุมานนั้นง่ายเนื่องจากโมเดลรองรับวิธี generate() ของ HuggingFace

ฟังก์ชั่น

• ส่งออกโมเดล T5 ที่ได้รับการฝึกฝนไปยัง onnx ได้อย่างง่ายดาย (ด้วย past_key_values )
• โมเดลที่ส่งออกรองรับการค้นหาลำแสงและการค้นหาโลภและอื่น ๆ ผ่านวิธี generate()
• ลดขนาดโมเดลลง 3X โดยใช้ quantization
• การเร่งความเร็วสูงสุด 5X เมื่อเทียบกับการดำเนินการ Pytorch สำหรับการค้นหาโลภและ 3-4X สำหรับการค้นหาลำแสง

เกณฑ์มาตรฐาน

เกณฑ์มาตรฐานเป็นผลมาจากแบบจำลอง T5-base ที่ทดสอบในการแปลภาษาอังกฤษเป็นภาษาฝรั่งเศส

รุ่น ONNX

กราฟต่อไปนี้แสดงเวลาแฝงของโมเดล ONNX เชิงปริมาณเทียบกับโมเดล pytorch สำหรับหมายเลขลำแสงแตกต่างกันไปตั้งแต่ 1 ถึง 9 เวลาแฝงที่แสดงที่นี่สำหรับค่าเฉลี่ยของความยาวลำดับสูงถึง 130

แผนที่ความร้อนต่อไปนี้แสดงให้เห็นเร็วขึ้น X ซึ่งอัตราส่วนของเวลาแฝงของ pytorch ต่อรุ่น ONNX โมเดล ONNX มีประสิทธิภาพสูงกว่ากรณีส่วนใหญ่ อย่างไรก็ตามความเร็วของโมเดลลดลงตามลำดับความยาวที่ยาวขึ้น

รูปแบบ ONNX ที่เป็นปริมาณ

แบบจำลองเชิงปริมาณเป็นรุ่นที่มีน้ำหนักเบาตามที่กล่าวไว้ก่อนหน้านี้รุ่นเหล่านี้มีความแม่นยำเกือบเท่ากันกับรุ่นดั้งเดิม (คะแนนโมเดลเชิงปริมาณถูกกล่าวถึงในส่วนถัดไป) แบบจำลอง ONNX ที่มีปริมาณมีเวลาแฝงต่ำที่สุดเมื่อเทียบกับทั้งรุ่น ONNX & Pytorch

โมเดลมีประสิทธิภาพสูงกว่ารุ่น Pytorch โดย 5.7x สำหรับการค้นหาโลภโดยเฉลี่ยและ 3-4x สำหรับการค้นหาลำแสง

หมายเหตุ: ผลลัพธ์ถูกสร้างขึ้นบน AMD EPYC 7B12 ผลลัพธ์เหล่านี้อาจแตกต่างกันไปในแต่ละอุปกรณ์สู่อุปกรณ์ รุ่น ONNX มักจะทำงานได้ดีบนซีพียูระดับสูงที่มีแกนมากขึ้น

คะแนนแบบจำลองเชิงปริมาณ

ผลลัพธ์ได้รับการทดสอบสำหรับการแปลภาษาอังกฤษเป็นภาษาฝรั่งเศสด้วยหมายเลขการค้นหาลำแสง 3

	bleu_4	ดาวตก	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 ขนาดใหญ่ (QUANT)	0.286726	0.316845	0.503585
T5 ขนาดใหญ่ (pytorch)	0.294015	0.315774	0.508677

โมเดลฮับโมเดลส่วนตัว HuggingFace

HuggingFace Model Hub รองรับโมเดลส่วนตัว ในการใช้ T5 รุ่นส่วนตัวที่ได้รับการฝึกฝนมาก่อนกับ FASTT5 คุณต้องได้รับการรับรองความถูกต้องเป็นระบบนิเวศ HuggingFace ด้วย $ transformers-cli login จากนั้นเมื่อใช้ FASTT5 จะมีการนำเข้าและโทรพิเศษ:

 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

set_auth_token คุณไม่สามารถโทรเข้า $ transformers-cli login หรือชอบใช้คีย์ API ของคุณพบได้ที่ https://huggingface.co/settings/token (หรือ https://huggingface.co/organizations/org_name/settings/token สำหรับองค์กร) หลีกเลี่ยงการเข้ารหัสคีย์ API ของคุณเป็นรหัสโดยการตั้งค่าตัวแปรสภาพแวดล้อม HF_API_KEY=<redacted> จากนั้นในรหัส:

 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 

การปรับปรุงเพิ่มเติม

• ปัจจุบันไลบรารี FASTT5 รองรับเฉพาะรุ่น CPU ของ ONNXRuntime เท่านั้นการใช้งาน GPU ยังคงต้องทำ
• การเพิ่มประสิทธิภาพกราฟของโมเดล ONNX จะลดเวลาแฝงต่อไป

รับความช่วยเหลือ

• ติดต่อฉันได้ที่ [email protected]
• หากเหมาะสมให้เปิดปัญหาเกี่ยวกับ GitHub

กิตติกรรมประกาศ

• กระดาษ T5 ต้นฉบับ
• Transformers by huggingface
• onnx
• onnxruntime โดย Microsoft
• onnxt5

 @ 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 },
}