ขอแนะนำ 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

คุณดูการทำงานของงานนี้ได้จากการสาธิต MediaPipe Studio ดูข้อมูลเพิ่มเติมเกี่ยวกับความสามารถ รูปแบบ และตัวเลือกการกําหนดค่าของงานนี้ได้ที่ภาพรวม

ตัวอย่างโค้ด

ตัวอย่างแอปพลิเคชันสำหรับ LLM Inference API มีการใช้งานพื้นฐานของงานนี้ใน JavaScript ไว้ให้คุณใช้เป็นข้อมูลอ้างอิง คุณสามารถใช้แอปตัวอย่างนี้เพื่อเริ่มต้นสร้างแอปการสร้างข้อความของคุณเอง

คุณสามารถเข้าถึง LLM Inference API ตัวอย่างแอปใน GitHub

ตั้งค่า

ส่วนนี้จะอธิบายขั้นตอนสําคัญในการตั้งค่าสภาพแวดล้อมการพัฒนาและโค้ดโปรเจ็กต์เพื่อใช้ LLM Inference API โดยเฉพาะ ดูข้อมูลทั่วไปเกี่ยวกับการตั้งค่าสภาพแวดล้อมการพัฒนาเพื่อใช้ MediaPipe Tasks รวมถึงข้อกำหนดเวอร์ชันแพลตฟอร์มได้ที่คู่มือการตั้งค่าสําหรับเว็บ

ความเข้ากันได้กับเบราว์เซอร์

LLM Inference API ต้องใช้เว็บเบราว์เซอร์ที่เข้ากันได้กับ WebGPU ดูรายการเบราว์เซอร์ที่เข้ากันได้ทั้งหมดได้ที่ความเข้ากันได้ของเบราว์เซอร์กับ GPU

แพ็กเกจ JavaScript

โค้ด LLM Inference API พร้อมใช้งานผ่านแพ็กเกจ @mediapipe/tasks-genai คุณค้นหาและดาวน์โหลดไลบรารีเหล่านี้ได้จากลิงก์ที่ให้ไว้ในคู่มือการตั้งค่าแพลตฟอร์ม

ติดตั้งแพ็กเกจที่จําเป็นสําหรับการจัดเตรียมเวอร์ชันที่ใช้งานจริงในเครื่อง

npm install @mediapipe/tasks-genai

หากต้องการติดตั้งใช้งานในเซิร์ฟเวอร์ ให้ใช้บริการเครือข่ายนำส่งข้อมูล (CDN) เช่น jsDelivr เพื่อเพิ่มโค้ดลงในหน้า HTML โดยตรง ดังนี้

<head>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
    crossorigin="anonymous"></script>
</head>

รุ่น

MediaPipe LLM Inference API ต้องใช้โมเดลที่ผ่านการฝึกอบรมซึ่งเข้ากันได้กับงานนี้ สำหรับเว็บแอปพลิเคชัน โมเดลต้องเข้ากันได้กับ GPU

ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลที่ผ่านการฝึกแล้วซึ่งมีให้ใช้งานสําหรับ LLM Inference API ได้ที่ส่วนโมเดลในภาพรวมของงาน

ดาวน์โหลดโมเดล

ก่อนเริ่มต้น LLM Inference API ให้ดาวน์โหลดโมเดลที่รองรับรายการใดรายการหนึ่งต่อไปนี้และจัดเก็บไฟล์ไว้ในไดเรกทอรีโปรเจ็กต์

Gemma-2 2B: รุ่นล่าสุดของตระกูล Gemma เป็นส่วนหนึ่งของกลุ่มโมเดลแบบเปิดที่ทันสมัยและน้ำหนักเบาซึ่งสร้างขึ้นจากงานวิจัยและเทคโนโลยีเดียวกันกับที่ใช้สร้างโมเดล Gemini
Gemma 2B:เป็นส่วนหนึ่งของกลุ่มโมเดลแบบเปิดที่ทันสมัยและน้ำหนักเบาซึ่งสร้างขึ้นจากงานวิจัยและเทคโนโลยีเดียวกันกับที่ใช้สร้างโมเดล Gemini เหมาะสําหรับงานการสร้างข้อความที่หลากหลาย ซึ่งรวมถึงการตอบคําถาม การสรุป และการหาเหตุผล
Phi-2: โมเดล Transformer ที่มีพารามิเตอร์ 2.7 พันล้านรายการ ซึ่งเหมาะสําหรับรูปแบบคําถามและคําตอบ แชท และโค้ด
Falcon-RW-1B: โมเดลเฉพาะตัวถอดรหัสเชิงสาเหตุที่มีพารามิเตอร์ 1,000 ล้านรายการซึ่งได้รับการฝึกด้วยโทเค็น 350,000 ล้านรายการจาก RefinedWeb
StableLM-3B: โมเดลภาษาแบบตัวถอดรหัสพารามิเตอร์เท่านั้นที่มี 3 พันล้านพารามิเตอร์ ซึ่งได้รับการฝึกล่วงหน้าด้วยโทเค็น 1 ล้านล้านรายการจากชุดข้อมูลภาษาอังกฤษและโค้ดที่หลากหลาย

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

เราขอแนะนําให้ใช้ Gemma-2 2B ซึ่งมีอยู่ใน Kaggle Models ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลอื่นๆ ที่มีได้ที่ภาพรวมของงานในส่วนโมเดล

แปลงโมเดลเป็นรูปแบบ 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 หากต้องการดูวิธีแปลงรูปแบบอื่นๆ โปรดดูส่วนการแปลงรูปแบบ

เพิ่มโมเดลลงในไดเรกทอรีโปรเจ็กต์

จัดเก็บโมเดลภายในไดเรกทอรีโปรเจ็กต์

<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin

ระบุเส้นทางของโมเดลด้วยพารามิเตอร์baseOptionsออบเจ็กต์ modelAssetPath ดังนี้

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}

สร้างงาน

ใช้ฟังก์ชัน createFrom...() ของ LLM Inference API อย่างใดอย่างหนึ่งเพื่อเตรียมงานสำหรับการดําเนินการอนุมาน คุณสามารถใช้ฟังก์ชัน createFromModelPath() กับเส้นทางแบบสัมพัทธ์หรือแบบสัมบูรณ์ไปยังไฟล์โมเดลที่ผ่านการฝึก ตัวอย่างโค้ดใช้ฟังก์ชัน createFromOptions() ดูข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกการกำหนดค่าที่ใช้ได้ได้ที่ตัวเลือกการกำหนดค่า

โค้ดต่อไปนี้แสดงวิธีสร้างและกําหนดค่างานนี้

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
    baseOptions: {
        modelAssetPath: '/assets/gemma-2b-it-gpu-int4.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

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

งานนี้มีตัวเลือกการกำหนดค่าต่อไปนี้สำหรับแอปเว็บและ JavaScript

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

เตรียมข้อมูล

LLM Inference API ยอมรับข้อมูลข้อความ (string) งานจะจัดการการประมวลผลข้อมูลก่อนป้อน ซึ่งรวมถึงการแยกคำและการประมวลผลเทนเซอร์ก่อนป้อน

ระบบจะจัดการการประมวลผลข้อมูลล่วงหน้าทั้งหมดภายในฟังก์ชัน generateResponse() โดยไม่จำเป็นต้องประมวลผลข้อความอินพุตเพิ่มเติม

const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";

เรียกใช้งาน

LLM Inference API ใช้ฟังก์ชัน generateResponse() เพื่อทริกเกอร์การอนุมาน สําหรับการจัดประเภทข้อความ การดำเนินการนี้จะแสดงหมวดหมู่ที่เป็นไปได้สําหรับข้อความที่ป้อน

โค้ดต่อไปนี้แสดงวิธีดำเนินการประมวลผลด้วยรูปแบบงาน

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

หากต้องการสตรีมคำตอบ ให้ใช้คำสั่งต่อไปนี้

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

จัดการและแสดงผลลัพธ์

LLM Inference API จะแสดงผลสตริงซึ่งมีข้อความตอบกลับที่สร้างขึ้น

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

การปรับแต่งโมเดล 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)

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

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

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

เว็บรองรับ LoRA แบบไดนามิกระหว่างรันไทม์ กล่าวคือ ผู้ใช้จะประกาศลําดับ LoRA ที่จะใช้ในการเริ่มต้น และสามารถสลับรูปแบบ LoRA ที่แตกต่างกันได้ในระหว่างรันไทม์

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
    // options for the base model
    ...
    // LoRA ranks to be used by the LoRA models during runtime
    loraRanks: [4, 8, 16]
});

ในระหว่างรันไทม์ หลังจากโมเดลฐานเริ่มต้นแล้ว ให้โหลดโมเดล LoRA ที่จะใช้งาน นอกจากนี้ ให้ทริกเกอร์โมเดล LoRA ด้วยการส่งข้อมูลอ้างอิงโมเดล LoRA ขณะสร้างคำตอบ LLM

// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);

// Specify LoRA model to be used during inference
llmInference.generateResponse(
  inputPrompt,
  loraModelRank4,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});