ขอแนะนำ LiteRT: รันไทม์ประสิทธิภาพสูงของ Google สำหรับ AI ในอุปกรณ์ หรือที่รู้จักกันในชื่อ TensorFlow Lite

หน้านี้ได้รับการแปลโดย Cloud Translation API

คู่มือการสรุป LLM

LLM Inference API ช่วยให้คุณเรียกใช้โมเดลภาษาขนาดใหญ่ (LLM) บนอุปกรณ์ได้ทั้งหมด ซึ่งคุณใช้เพื่อทำงานได้หลากหลาย เช่น การสร้างข้อความ การดึงข้อมูลในรูปแบบภาษาธรรมชาติ และการสรุปเอกสาร งานนี้รองรับโมเดลภาษาขนาดใหญ่แบบข้อความเป็นข้อความหลายรายการในตัว คุณจึงใช้โมเดล Generative AI บนอุปกรณ์ล่าสุดกับแอปและผลิตภัณฑ์ได้

ลองใช้เลย

แท็บนี้จะรองรับตัวแปรต่อไปนี้ของ Gemma ได้แก่ Gemma-2 2B, Gemma 2B และ Gemma 7B Gemma เป็นกลุ่มผลิตภัณฑ์โมเดลแบบเปิดที่ทันสมัยและน้ำหนักเบา ซึ่งสร้างขึ้นจากงานวิจัยและเทคโนโลยีเดียวกับที่ใช้สร้างโมเดล Gemini และยังรองรับรุ่นภายนอกต่อไปนี้ด้วย Phi-2, Falcon-RW-1B และ StableLM-3B

นอกจากโมเดลที่รองรับแล้ว คุณยังใช้ AI Edge Torch ของ Google เพื่อส่งออกโมเดล PyTorch ไปยังโมเดล LiteRT (tflite) ที่มีลายเซ็นหลายรายการได้ ซึ่งจะรวมอยู่กับพารามิเตอร์ตัวแยกวิเคราะห์เพื่อสร้างกลุ่มงานที่เข้ากันได้กับ LLM Inference API โมเดลที่แปลงด้วย AI Edge Torch จะทำงานได้ในแบ็กเอนด์ CPU เท่านั้น จึงใช้ได้กับ Android และ iOS เท่านั้น

เริ่มต้นใช้งาน

เริ่มใช้แท็บงานนี้โดยทําตามคําแนะนําการใช้งานแพลตฟอร์มเป้าหมายรายการใดรายการหนึ่งต่อไปนี้ คำแนะนำเฉพาะแพลตฟอร์มเหล่านี้จะแนะนำการใช้งานพื้นฐานของงานนี้พร้อมตัวอย่างโค้ดที่ใช้โมเดลที่มีอยู่และตัวเลือกการกำหนดค่าที่แนะนำ

รายละเอียดงาน

ส่วนนี้จะอธิบายความสามารถ อินพุต เอาต์พุต และตัวเลือกการกำหนดค่าของงานนี้

ฟีเจอร์

LLM Inference API มีฟีเจอร์หลักต่อไปนี้

การสร้างข้อความจากข้อความ - สร้างข้อความตามพรอมต์ข้อความอินพุต
การเลือก LLM - ใช้หลายรูปแบบเพื่อปรับแต่งแอปให้เหมาะกับกรณีการใช้งานที่เฉพาะเจาะจง นอกจากนี้ คุณยังฝึกและนำน้ำหนักที่กำหนดเองไปใช้กับโมเดลได้ด้วย
การรองรับ LoRA - ขยายและปรับแต่งความสามารถของ LLM ด้วยโมเดล LoRA โดยการฝึกกับชุดข้อมูลทั้งหมด หรือใช้โมเดล LoRA ที่เตรียมไว้ล่วงหน้าจากชุมชนโอเพนซอร์ส (ใช้ร่วมกับโมเดลที่แปลงด้วย AI Edge Torch Generative API ไม่ได้)

อินพุตงาน	เอาต์พุตของงาน
LLM Inference API ยอมรับอินพุตต่อไปนี้ พรอมต์ข้อความ (เช่น คำถาม เรื่องอีเมล เอกสารที่จะสรุป)	LLM Inference API จะแสดงผลลัพธ์ต่อไปนี้ ข้อความที่สร้างขึ้นตามพรอมต์การป้อนข้อมูล (เช่น คำตอบสำหรับคำถาม อีเมลฉบับร่าง ข้อมูลสรุปของเอกสาร)

ตัวเลือกการกําหนดค่า

งานนี้มีตัวเลือกการกำหนดค่าต่อไปนี้

ชื่อตัวเลือก	คำอธิบาย	ช่วงของค่า	ค่าเริ่มต้น
`modelPath`	เส้นทางไปยังตำแหน่งที่จัดเก็บโมเดลภายในไดเรกทอรีโปรเจ็กต์	PATH	ไม่มี
`maxTokens`	จํานวนโทเค็นสูงสุด (โทเค็นอินพุต + โทเค็นเอาต์พุต) ที่โมเดลจัดการได้	จำนวนเต็ม	512
`topK`	จำนวนโทเค็นที่โมเดลพิจารณาในแต่ละขั้นตอนของการสร้าง จำกัดการคาดการณ์ไว้ที่โทเค็นที่เป็นไปได้มากที่สุด k รายการแรก	จำนวนเต็ม	40
`temperature`	ระดับความสุ่มที่เกิดขึ้นระหว่างการสร้าง อุณหภูมิที่สูงขึ้นจะทำให้ข้อความที่สร้างขึ้นมีความสร้างสรรค์มากขึ้น ขณะที่อุณหภูมิที่ต่ำลงจะทำให้การสร้างขึ้นมีความคาดเดาได้มากขึ้น	ทศนิยม	0.8
`randomSeed`	เมล็ดพันธุ์แบบสุ่มที่ใช้ระหว่างการสร้างข้อความ	จำนวนเต็ม	0
`loraPath`	เส้นทางแบบสัมบูรณ์ไปยังโมเดล LoRA ในอุปกรณ์ หมายเหตุ: ใช้ได้กับ GPU บางรุ่นเท่านั้น	PATH	ไม่มี
`resultListener`	ตั้งค่าโปรแกรมรับฟังผลลัพธ์ให้รับผลลัพธ์แบบไม่พร้อมกัน ใช้ได้เฉพาะเมื่อใช้วิธีการสร้างแบบแอสซิงค์เท่านั้น	ไม่มี	ไม่มี
`errorListener`	ตั้งค่าโปรแกรมรับฟังข้อผิดพลาด (ไม่บังคับ)	ไม่มี	ไม่มี

โมเดล

LLM Inference API รองรับโมเดลภาษาขนาดใหญ่แบบข้อความต่อข้อความหลายโมเดล รวมถึงการรองรับโมเดลหลายรายการในตัวซึ่งได้รับการเพิ่มประสิทธิภาพให้ทำงานในเบราว์เซอร์และอุปกรณ์เคลื่อนที่ โมเดลขนาดเบาเหล่านี้สามารถใช้เพื่อเรียกใช้การอนุมานในอุปกรณ์ได้ทั้งหมด

ก่อนเริ่มต้น LLM Inference API ให้ดาวน์โหลดโมเดลและจัดเก็บไฟล์ภายในไดเรกทอรีโปรเจ็กต์ คุณสามารถใช้โมเดลที่แปลงไว้ล่วงหน้าหรือแปลงโมเดลเป็นรูปแบบที่ MediaPipe รองรับก็ได้

LLM Inference API ใช้ได้กับโมเดล 2 ประเภท ซึ่งบางประเภทต้องมีการแปลงโมเดล ใช้ตารางเพื่อระบุขั้นตอนและวิธีการที่จำเป็นสำหรับโมเดลของคุณ

	โมเดล	วิธีการแปลง	แพลตฟอร์มที่เข้ากันได้	ประเภทไฟล์
รุ่นที่รองรับ	Gemma 2B, Gemma 7B, Gemma-2 2B, Phi-2, StableLM, Falcon	MediaPipe	Android, iOS, เว็บ	.bin
โมเดล PyTorch อื่นๆ	โมเดล LLM ของ PyTorch ทั้งหมด	ไลบรารี Generative ของ AI Edge Torch	Android, iOS	.task

เราโฮสต์ไฟล์ .bin ที่แปลงแล้วสำหรับ Gemma 2B, Gemma 7B และ Gemma-2 2B บน Kaggle คุณทำให้โมเดลเหล่านี้ใช้งานได้โดยตรงโดยใช้ LLM Inference API หากต้องการดูวิธีแปลงรูปแบบอื่นๆ โปรดดูส่วนการแปลงรูปแบบ

Gemma-2 2B

Gemma-2 2B เป็นโมเดลล่าสุดในตระกูล Gemma ซึ่งเป็นโมเดลแบบเปิดที่ทันสมัยและน้ำหนักเบาที่สร้างขึ้นจากงานวิจัยและเทคโนโลยีเดียวกับที่ใช้สร้างโมเดล Gemini โมเดลมีพารามิเตอร์ 2 พันล้านรายการและน้ำหนักแบบเปิด Gemma-2 2B ขึ้นชื่อเรื่องทักษะการหาเหตุผลที่ล้ำสมัยสำหรับโมเดลในรุ่น

ดาวน์โหลด Gemma-2 2B

รุ่น Gemma-2 2B มีให้เลือก 2 รุ่นดังนี้

gemma2-2b-it-cpu-int8: Gemma-2 2B รุ่น 8 บิตที่เข้ากันได้กับ CPU
gemma2-2b-it-gpu-int8: Gemma-2 2B รุ่น 8 บิตที่ใช้งานร่วมกับ GPU ได้

นอกจากนี้ คุณยังปรับแต่งโมเดลและเพิ่มน้ำหนักใหม่ก่อนที่จะเพิ่มลงในแอปได้ด้วย ดูข้อมูลเพิ่มเติมเกี่ยวกับการปรับแต่งและปรับแต่ง Gemma ได้ที่การปรับแต่ง Gemma หลังจากดาวน์โหลด Gemma-2 2B จาก Kaggle Models แล้ว โมเดลจะอยู่ในรูปแบบที่เหมาะสมสำหรับใช้กับ MediaPipe Tasks อยู่แล้ว

Gemma 2B

Gemma 2B เป็นส่วนหนึ่งของกลุ่มโมเดลแบบเปิดที่ทันสมัยและน้ำหนักเบาซึ่งสร้างขึ้นจากงานวิจัยและเทคโนโลยีเดียวกับที่ใช้สร้างโมเดล Gemini โมเดลมีพารามิเตอร์ 2B และการถ่วงน้ำหนักแบบเปิด โมเดลนี้เหมาะสําหรับงานการสร้างข้อความที่หลากหลาย ซึ่งรวมถึงการตอบคําถาม การสรุป และการหาเหตุผล

ดาวน์โหลด Gemma 2B

รุ่น Gemma 2B มีให้เลือก 2 รุ่นดังนี้

gemma-2b-it-cpu-int4: Gemma 2B รุ่น 4 บิตที่เข้ากันได้กับ CPU
gemma-2b-it-cpu-int8: Gemma 2B รุ่น 8 บิตที่ใช้งานร่วมกับ CPU ได้
gemma-2b-it-gpu-int4: Gemma 2B รุ่น 4 บิตที่เข้ากันได้กับ GPU
gemma-2b-it-gpu-int8: Gemma 2B รุ่น 8 บิตที่เข้ากันได้กับ GPU

นอกจากนี้ คุณยังปรับแต่งโมเดลและเพิ่มน้ำหนักใหม่ก่อนที่จะเพิ่มลงในแอปได้ด้วย ดูข้อมูลเพิ่มเติมเกี่ยวกับการปรับแต่งและปรับแต่ง Gemma ได้ที่การปรับแต่ง Gemma หลังจากดาวน์โหลด Gemma 2B จาก Kaggle Models แล้ว โมเดลจะอยู่ในรูปแบบที่เหมาะสมสำหรับใช้กับ MediaPipe Tasks อยู่แล้ว

Gemma 7B

Gemma 7B เป็น Gemma รุ่นที่ใหญ่ขึ้นซึ่งมีพารามิเตอร์ 7B และน้ำหนักแบบเปิด โมเดลนี้มีประสิทธิภาพมากขึ้นสำหรับงานการสร้างข้อความที่หลากหลาย ซึ่งรวมถึงการตอบคำถาม การสรุป และการหาเหตุผล Gemma 7B ใช้ได้ในเว็บเท่านั้น

ดาวน์โหลด Gemma 7B

รุ่น Gemma 7B มี 1 ตัวแปร ได้แก่

gemma-1.1-7b-it-gpu-int8: Gemma 7B รุ่น 8 บิตที่เข้ากันได้กับ GPU

หลังจากดาวน์โหลด Gemma 7B จากโมเดลของ Kaggle แล้ว โมเดลจะอยู่ในรูปแบบที่เหมาะสมสำหรับใช้กับ MediaPipe

Falcon 1B

Falcon-1B เป็นโมเดลเฉพาะตัวถอดรหัสเชิงสาเหตุที่มีพารามิเตอร์ 1 พันล้านรายการ ซึ่งได้รับการฝึกด้วยโทเค็น 350,000 ล้านรายการจาก RefinedWeb

ดาวน์โหลด Falcon 1B

LLM Inference API กำหนดให้ต้องดาวน์โหลดและจัดเก็บไฟล์ต่อไปนี้ไว้ในเครื่อง

tokenizer.json
tokenizer_config.json
pytorch_model.bin

หลังจากดาวน์โหลดไฟล์โมเดล Falcon แล้ว โมเดลจะพร้อมแปลงเป็นรูปแบบ MediaPipe ด้วยสคริปต์การแปลง ทําตามขั้นตอนในส่วนสคริปต์ Conversion สําหรับรูปแบบที่รองรับ

StableLM 3B

StableLM-3B คือโมเดลภาษาแบบตัวถอดรหัสเท่านั้นที่มีพารามิเตอร์ 3,000 ล้านรายการ ซึ่งได้รับการฝึกล่วงหน้าด้วยชุดข้อมูลโค้ดและภาษาอังกฤษที่หลากหลาย 1 ล้านล้านโทเค็นเป็นเวลา 4 ยุค

ดาวน์โหลด StableLM 3B

LLM Inference API กำหนดให้ต้องดาวน์โหลดและจัดเก็บไฟล์ต่อไปนี้ไว้ในเครื่อง

tokenizer.json
tokenizer_config.json
model.safetensors

หลังจากดาวน์โหลดไฟล์โมเดล StableLM แล้ว โมเดลจะพร้อมแปลงเป็นรูปแบบ MediaPipe ด้วยสคริปต์การแปลง ทําตามขั้นตอนในส่วนสคริปต์ Conversion สําหรับรูปแบบที่รองรับ

Phi-2

Phi-2 คือโมเดล Transformer ที่มีพารามิเตอร์ 2.7 พันล้านรายการ ได้รับการฝึกโดยใช้ข้อความสังเคราะห์ NLP และเว็บไซต์ที่กรองแล้วต่างๆ โมเดลนี้เหมาะสําหรับพรอมต์ที่ใช้รูปแบบคําถามและคําตอบ แชท และโค้ด

ดาวน์โหลด Phi-2

LLM Inference API กำหนดให้ต้องดาวน์โหลดและจัดเก็บไฟล์ต่อไปนี้ไว้ในเครื่อง

tokenizer.json
tokenizer_config.json
model-00001-of-00002.safetensors
model-00002-of-00002.safetensors

หลังจากดาวน์โหลดไฟล์โมเดล Phi-2 แล้ว โมเดลจะพร้อมแปลงเป็นรูปแบบ MediaPipe ด้วยสคริปต์การแปลง ทําตามขั้นตอนในส่วนสคริปต์ Conversion สําหรับรูปแบบที่รองรับ

โมเดล PyTorch แบบ Generative

โมเดล Generative ของ PyTorch สามารถแปลงเป็นรูปแบบที่เข้ากันได้กับ MediaPipe ได้ด้วย AI Edge Torch Generative API คุณสามารถใช้ API เพื่อแปลงโมเดล PyTorch เป็นโมเดล LiteRT (TensorFlow Lite) ที่มีลายเซ็นหลายรายการ ดูรายละเอียดเพิ่มเติมเกี่ยวกับการแมปและการส่งออกโมเดลได้ที่หน้า GitHub ของ AI Edge Torch

หากต้องการใช้ AI Edge Torch Generative API เพื่อแปลงโมเดล PyTorch ให้ทำตามขั้นตอนในส่วนเครื่องมือแปลง Torch Generative สำหรับโมเดล PyTorch

การแปลงโมเดล

MediaPipe LLM Inference API ช่วยให้คุณเรียกใช้โมเดลภาษาขนาดใหญ่ที่หลากหลายในอุปกรณ์ได้ ซึ่งรวมถึงโมเดลที่แปลงเป็นรูปแบบที่เข้ากันได้กับ MediaPipe ไว้ล่วงหน้า รวมถึงโมเดลอื่นๆ ที่แปลงได้ด้วยสคริปต์การแปลงหรือไลบรารี AI Edge Torch

LLM Inference API ยอมรับโมเดลในรูปแบบไฟล์ .bin และ .task โมเดลที่แปลงไว้ล่วงหน้าและโมเดลที่แปลงด้วยสคริปต์การแปลงจะเป็นไฟล์ .bin ส่วนโมเดลที่แปลงด้วยไลบรารี AI Edge Torch จะเป็นไฟล์ .task อย่าแก้ไขรูปแบบไฟล์ของโมเดลที่แปลงด้วยตนเอง

LLM Inference API มีเส้นทาง Conversion ของรูปแบบ 3 เส้นทาง ได้แก่

โมเดลที่แปลงล่วงหน้า (Gemma 2B, Gemma 7B, Gemma-2 2B): ไม่จำเป็นต้องแปลง
โมเดลที่รองรับ (Phi-2, StableLM, Falcon): สคริปต์การเปลี่ยนรูปแบบของ MediaPipe
โมเดล PyTorch อื่นๆ (โมเดล LLM ทั้งหมดของ PyTorch): AI Edge Torch Generative API

โมเดลที่แปลงไว้ล่วงหน้า

โมเดล Gemma-2 2B, Gemma 2B และ Gemma 7B มีให้บริการเป็นโมเดลที่แปลงไว้ล่วงหน้าในรูปแบบ MediaPipe โมเดลเหล่านี้ไม่จําเป็นต้องแปลงรูปแบบเพิ่มเติมจากผู้ใช้และสามารถทํางานได้โดยไม่ต้องเปลี่ยนแปลงใดๆ กับ LLM Inference API

คุณดาวน์โหลด Gemma-2 2B ได้จากโมเดล Kaggle ดังนี้

gemma2-2b-it-cpu-int8: Gemma-2 2B รุ่น 8 บิตที่เข้ากันได้กับ CPU
gemma2-2b-it-gpu-int8: Gemma-2 2B รุ่น 8 บิตที่ใช้งานร่วมกับ GPU ได้

คุณดาวน์โหลดตัวแปรของ Gemma 2B จากโมเดล Kaggle ได้โดยทำดังนี้

gemma-2b-it-cpu-int4: Gemma 2B รุ่น 4 บิตที่เข้ากันได้กับ CPU
gemma-2b-it-cpu-int8: Gemma 2B รุ่น 8 บิตที่ใช้งานร่วมกับ CPU ได้
gemma-2b-it-gpu-int4: Gemma 2B รุ่น 4 บิตที่เข้ากันได้กับ GPU
gemma-2b-it-gpu-int8: Gemma 2B รุ่น 8 บิตที่เข้ากันได้กับ GPU

คุณดาวน์โหลด Gemma 7B ได้จากโมเดล Kaggle ดังนี้

gemma-1.1-7b-it-gpu-int8: Gemma 7B รุ่น 8 บิตที่เข้ากันได้กับ GPU

ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดล Gemma ได้ที่เอกสารประกอบเกี่ยวกับ Gemma-2 2B, Gemma 2B และ Gemma 7B

สคริปต์ Conversion สําหรับรูปแบบที่รองรับ

แพ็กเกจ MediaPipe มีสคริปต์แปลงเพื่อแปลงโมเดลภายนอกต่อไปนี้ให้เป็นรูปแบบที่เข้ากันได้กับ MediaPipe

ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลภายนอกที่รองรับได้ที่เอกสารประกอบเกี่ยวกับ Falcon 1B, StableLM 3B และ Phi-2

กระบวนการแปลงโมเดลต้องใช้แพ็กเกจ MediaPipe PyPI สคริปต์การเปลี่ยนรูปแบบจะอยู่ในแพ็กเกจ MediaPipe ทั้งหมดหลังจาก 0.10.11

ติดตั้งและนําเข้าทรัพยากร Dependency ด้วยสิ่งต่อไปนี้

$ python3 -m pip install mediapipe

ใช้ไลบรารี genai.converter เพื่อแปลงโมเดล โดยทำดังนี้

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

หากต้องการแปลงรูปแบบ LoRA ConversionConfig ควรระบุตัวเลือกรูปแบบพื้นฐาน รวมถึงตัวเลือก LoRA เพิ่มเติม โปรดทราบว่าเนื่องจาก API รองรับการอนุมาน LoRA ด้วย GPU เท่านั้น จึงต้องตั้งค่าแบ็กเอนด์เป็น 'gpu'

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

ตัวแปลงจะแสดงผลไฟล์ Flatbuffer ของ TFLite 2 ไฟล์ ไฟล์หนึ่งสำหรับโมเดลฐานและอีกไฟล์สำหรับโมเดล LoRA

พารามิเตอร์	คำอธิบาย	ค่าที่ยอมรับ
`input_ckpt`	เส้นทางไปยังไฟล์ `model.safetensors` หรือ `pytorch.bin` โปรดทราบว่าบางครั้งรูปแบบ safetensors ของโมเดลจะแบ่งออกเป็นหลายไฟล์ เช่น `model-00001-of-00003.safetensors`, `model-00001-of-00003.safetensors` คุณสามารถระบุรูปแบบไฟล์ เช่น `model*.safetensors`	PATH
`ckpt_format`	รูปแบบไฟล์โมเดล	{"safetensors", "pytorch"}
`model_type`	LLM ที่กำลังแปลง	{"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
`backend`	โปรเซสเซอร์ (ผู้รับมอบสิทธิ์) ที่ใช้เรียกใช้โมเดล	{"cpu", "gpu"}
`output_dir`	เส้นทางไปยังไดเรกทอรีเอาต์พุตที่โฮสต์ไฟล์น้ำหนักต่อเลเยอร์	PATH
`output_tflite_file`	เส้นทางไปยังไฟล์เอาต์พุต เช่น "model_cpu.bin" หรือ "model_gpu.bin" ไฟล์นี้ใช้ได้กับ LLM Inference API เท่านั้น และใช้เป็นไฟล์ `tflite` ทั่วไปไม่ได้	PATH
`vocab_model_file`	เส้นทางไปยังไดเรกทอรีที่จัดเก็บไฟล์ `tokenizer.json` และ `tokenizer_config.json` สำหรับ Gemma ให้ชี้ไปที่ไฟล์ `tokenizer.model` ไฟล์เดียว	PATH
`lora_ckpt`	เส้นทางไปยัง ckpt LoRA ของไฟล์ safetensors ที่เก็บน้ำหนักของอะแดปเตอร์ LoRA	PATH
`lora_rank`	จํานวนเต็มที่แสดงลําดับของ LoRA ckpt ต้องระบุเพื่อแปลงน้ำหนัก lora หากไม่ได้ระบุ เครื่องมือแปลงจะถือว่าไม่มีน้ำหนัก LoRA หมายเหตุ: เฉพาะแบ็กเอนด์ GPU เท่านั้นที่รองรับ LoRA	จำนวนเต็ม
`lora_output_tflite_file`	ชื่อไฟล์ tflite สำหรับน้ำหนัก LoRA	PATH

ตัวแปลง Torch Generative สําหรับโมเดล PyTorch

โมเดล Generative ของ PyTorch สามารถแปลงเป็นรูปแบบที่เข้ากันได้กับ MediaPipe ได้ด้วย AI Edge Torch Generative API คุณสามารถใช้ API นี้เพื่อเขียน แปลง และแปลงค่า LLM ของ PyTorch เพื่อใช้กับ LLM Inference API ตัวแปลง Torch Generative จะแปลงสำหรับ CPU เท่านั้น และต้องใช้เครื่อง Linux ที่มี RAM อย่างน้อย 64 GB

การแปลงโมเดล PyTorch ด้วย AI Edge Torch Generative API ประกอบด้วยขั้นตอนต่อไปนี้

ดาวน์โหลดจุดตรวจโมเดล PyTorch
ใช้ AI Edge Torch Generative API เพื่อสร้าง แปลง และแปลงโมเดลเป็นรูปแบบไฟล์ที่เข้ากันได้กับ MediaPipe (.tflite)
สร้างกลุ่มงาน (.task) จากไฟล์ tflite และตัวแยกวิเคราะห์โมเดล

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

กระบวนการรวมโมเดลต้องใช้แพ็กเกจ MediaPipe PyPI สคริปต์การเปลี่ยนรูปแบบจะอยู่ในแพ็กเกจ MediaPipe ทั้งหมดหลังจาก 0.10.14

เพื่อหลีกเลี่ยงปัญหาความเข้ากันได้

ติดตั้งและนําเข้าทรัพยากร Dependency ด้วยสิ่งต่อไปนี้

$ python3 -m pip install mediapipe

ใช้ไลบรารี genai.bundler เพื่อรวมโมเดล

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

พารามิเตอร์	คำอธิบาย	ค่าที่ยอมรับ
`tflite_model`	เส้นทางไปยังโมเดล TFLite ที่ส่งออกของ AI Edge	PATH
`tokenizer_model`	เส้นทางไปยังโมเดลตัวแยกวิเคราะห์ SentencePiece	PATH
`start_token`	โทเค็นเริ่มต้นเฉพาะโมเดล โทเค็นเริ่มต้นต้องอยู่ในรูปแบบตัวแยกวิเคราะห์ที่ระบุ	STRING
`stop_tokens`	โทเค็นหยุดเฉพาะรุ่น โทเค็นสิ้นสุดต้องอยู่ในโมเดลตัวแยกวิเคราะห์ที่ระบุ	LIST[STRING]
`output_filename`	ชื่อไฟล์กลุ่มงานเอาต์พุต	PATH

การปรับแต่ง LoRA

คุณสามารถกําหนดค่า API การอนุมาน LLM ของ Mediapipe ให้รองรับการปรับรูปแบบตามลําดับชั้นต่ำ (LoRA) สําหรับโมเดลภาษาขนาดใหญ่ได้ การใช้โมเดล LoRA ที่ปรับแต่งมาอย่างดีช่วยให้นักพัฒนาแอปปรับแต่งลักษณะการทํางานของ LLM ผ่านกระบวนการฝึกที่ประหยัดค่าใช้จ่ายได้

การรองรับ LoRA ของ LLM Inference API ใช้ได้กับตัวแปร Gemma และโมเดล Phi-2 ทั้งหมดสําหรับแบ็กเอนด์ GPU โดยน้ำหนัก LoRA ใช้ได้กับเลเยอร์การใส่ใจเท่านั้น การใช้งานครั้งแรกนี้ถือเป็น API เวอร์ชันทดลองสําหรับการพัฒนาในอนาคต โดยมีแผนที่จะรองรับโมเดลและเลเยอร์ประเภทต่างๆ เพิ่มเติมในการอัปเดตที่กําลังจะมาถึง

เตรียมโมเดล LoRA

ทําตามวิธีการใน HuggingFace เพื่อฝึกโมเดล LoRA ที่ปรับแต่งอย่างละเอียดในชุดข้อมูลของคุณเองด้วยประเภทโมเดลที่รองรับ ซึ่งได้แก่ Gemma หรือ Phi-2 โมเดล Gemma-2 2B, Gemma 2B และ Phi-2 พร้อมใช้งานใน HuggingFace ในรูปแบบ SafeTensor เนื่องจาก LLM Inference API รองรับเฉพาะ LoRA ในเลเยอร์ความสนใจ ให้ระบุเฉพาะเลเยอร์ความสนใจขณะสร้าง LoraConfig ดังนี้

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

สำหรับการทดสอบ มีโมเดล LoRA ที่ปรับแต่งอย่างละเอียดซึ่งเข้ากันได้กับ LLM ที่พร้อมใช้งานแบบสาธารณะใน Inference API ของ HuggingFace เช่น monsterapi/gemma-2b-lora-maths-orca-200k สำหรับ Gemma-2B และ lole25/phi-2-sft-ultrachat-lora สำหรับ Phi-2

หลังจากฝึกชุดข้อมูลที่เตรียมไว้และบันทึกโมเดลแล้ว คุณจะได้รับไฟล์ adapter_model.safetensors ที่มีน้ำหนักโมเดล LoRA ที่ปรับแต่งอย่างละเอียด ไฟล์ safetensors คือจุดตรวจสอบ LoRA ที่ใช้ในการแปลงโมเดล

ขั้นตอนถัดไปคือคุณต้องแปลงน้ำหนักโมเดลเป็น TensorFlow Lite Flatbuffer โดยใช้แพ็กเกจ MediaPipe Python ConversionConfig ควรระบุตัวเลือกโมเดลพื้นฐานและตัวเลือก LoRA เพิ่มเติม โปรดทราบว่าเนื่องจาก API รองรับเฉพาะการอนุมาน LoRA ด้วย GPU จึงต้องตั้งค่าแบ็กเอนด์เป็น 'gpu'

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

การอนุมานโมเดล LoRA

อัปเดต LLM Inference API ของเว็บ, Android และ iOS เพื่อรองรับการอนุมานโมเดล LoRA

Android รองรับ LoRA แบบคงที่ระหว่างการเริ่มต้น หากต้องการโหลดโมเดล LoRA ผู้ใช้จะต้องระบุเส้นทางโมเดล LoRA และ LLM พื้นฐาน

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

หากต้องการเรียกใช้การอนุมาน LLM ด้วย LoRA ให้ใช้วิธีการ generateResponse() หรือ generateResponseAsync() เดียวกันกับโมเดลพื้นฐาน