ดูข้อมูลเพิ่มเติมเกี่ยวกับประกาศจาก I/O ของ Google AI Edge

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

คู่มือการสรุป LLM สำหรับเว็บ

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

คุณดูงานนี้ในการใช้งานจริงได้ในการสาธิต 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 ให้ดาวน์โหลดโมเดลที่รองรับมา 1 โมเดลและจัดเก็บไฟล์ไว้ในไดเรกทอรีโปรเจ็กต์ของคุณ

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

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

แปลงโมเดลเป็นรูปแบบ MediaPipe

Conversion รูปแบบเนทีฟ

หากคุณใช้ LLM ภายนอก (Phi-2, Falcon หรือ StableLM) หรือ Gemma เวอร์ชันที่ไม่ใช่ Kaggle ให้ใช้สคริปต์ Conversion ของเราเพื่อจัดรูปแบบโมเดลให้เข้ากันได้กับ MediaPipe

กระบวนการแปลงรูปแบบต้องใช้แพ็กเกจ MediaPipe PyPI สคริปต์ Conversion จะพร้อมใช้งานในแพ็กเกจ 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)

ตัวแปลงจะแสดงผลไฟล์ TFLite Flatbuffer 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`	เส้นทางไปยังไฟล์ LoRA ckpt ของไฟล์ Safetensors ที่จัดเก็บน้ำหนักของอะแดปเตอร์ LoRA	PATH
`lora_rank`	จำนวนเต็มที่แสดงอันดับของ LoRA ckpt ต้องระบุเพื่อแปลงน้ำหนักลอรา หากไม่ระบุ ตัวแปลงจะถือว่าไม่มีน้ำหนัก LoRA หมายเหตุ: เฉพาะแบ็กเอนด์ของ GPU เท่านั้นที่รองรับ LoRA	จำนวนเต็ม
`lora_output_tflite_file`	ชื่อไฟล์เอาต์พุต tflite สำหรับน้ำหนัก LoRA	PATH

การแปลงรูปแบบ AI Edge

หากคุณใช้ LLM ที่แมปกับโมเดล TFLite ผ่าน AI Edge ให้ใช้สคริปต์การรวมกลุ่มของเราเพื่อสร้าง Task Bundle กระบวนการรวมกลุ่มจะแพ็กโมเดลที่แมป พร้อมข้อมูลเมตาเพิ่มเติม (เช่น พารามิเตอร์ Tokenizer) เพื่อเรียกใช้การอนุมานจากต้นทางถึงปลายทาง

กระบวนการรวมกลุ่มโมเดลต้องใช้แพ็กเกจ MediaPipe PyPI สคริปต์ Conversion จะพร้อมใช้งานในแพ็กเกจ 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`	โทเค็นเริ่มต้นที่เจาะจงรุ่น โทเค็นเริ่มต้นต้องมีอยู่ในโมเดล Tokenizer ที่ระบุ	STRING
`stop_tokens`	โทเค็นการหยุดที่เจาะจงของโมเดล โทเค็นหยุดต้องมีอยู่ในโมเดล Tokenizer ที่ระบุ	รายการ [STRING]
`output_filename`	ชื่อของไฟล์กลุ่มงานเอาต์พุต	PATH

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

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

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

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

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

สร้างงาน

ใช้หนึ่งในฟังก์ชัน LLM Inference API createFrom...() เพื่อเตรียมงานสำหรับการเรียกใช้การอนุมาน คุณสามารถใช้ฟังก์ชัน 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`	จำนวนโทเค็นที่โมเดลจะพิจารณาในแต่ละขั้นตอนของการสร้าง จำกัดการคาดการณ์ไว้ที่โทเค็นที่เป็นไปได้มากที่สุดอันดับต้นๆ เมื่อตั้งค่า `topK` คุณต้องกำหนดค่าสำหรับ `randomSeed` ด้วย	จำนวนเต็ม	40
`temperature`	ปริมาณการสุ่มที่เกิดขึ้นระหว่างการสร้าง อุณหภูมิที่สูงขึ้นส่งผลให้ข้อความที่สร้างขึ้นมีความคิดสร้างสรรค์มากขึ้น ขณะที่อุณหภูมิที่ต่ำลงจะทําให้เกิดการสร้างที่คาดการณ์ได้มากขึ้น เมื่อตั้งค่า `temperature` คุณต้องกำหนดค่าสำหรับ `randomSeed` ด้วย	ทศนิยม	0.8
`randomSeed`	Seed แบบสุ่มที่ใช้ระหว่างการสร้างข้อความ	จำนวนเต็ม	0
`loraRanks`	LoRA จัดอันดับให้ใช้โดยโมเดล LoRA ระหว่างรันไทม์ หมายเหตุ: ใช้ได้กับรุ่น GPU เท่านั้น	อาร์เรย์จำนวนเต็ม	ไม่มีข้อมูล

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

LLM Inference API ยอมรับข้อความ (string) งานนี้จะจัดการการประมวลผลอินพุตข้อมูลล่วงหน้า ซึ่งรวมถึงการแปลงข้อมูลเป็นโทเค็นและการประมวลผลล่วงหน้าของ tensor

การประมวลผลล่วงหน้าทั้งหมดได้รับการจัดการภายในฟังก์ชัน 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

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

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

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

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

# For Gemma-2B
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

API การอนุมาน LLM บนเว็บ, Android และ iOS ได้รับการอัปเดตให้รองรับการอนุมานโมเดล LoRA เว็บรองรับ LoRA แบบไดนามิก ซึ่งเปลี่ยน LoRA รุ่นต่างๆ ได้ระหว่างรันไทม์ Android และ iOS รองรับ LoRA แบบคงที่ ซึ่งใช้น้ำหนัก 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;
});