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

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

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

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

งานรองรับ Gemma-2 2B ล่าสุดใน ตระกูลโมเดลแบบเปิดที่ทันสมัยและน้ำหนักเบา สร้างขึ้นจากการวิจัยเดียวกัน และเทคโนโลยีที่ใช้ในการสร้างโมเดล Gemini และยังรองรับรุ่นเพิ่มเติมต่อไปนี้ด้วย Gemma Phi-2 Falcon-RW-1B และ StableLM-3B รวมถึงโมเดลทั้งหมดที่ส่งออกผ่าน AI Edge

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับความสามารถ โมเดล และตัวเลือกการกำหนดค่า ของงานนี้ โปรดดูภาพรวม

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

คู่มือนี้กล่าวถึงตัวอย่างแอปการสร้างข้อความพื้นฐานสำหรับ Android คุณ สามารถใช้แอปนี้เป็นจุดเริ่มต้นสำหรับแอป Android ของคุณเอง หรืออ้างอิงถึงแอปนั้น เมื่อแก้ไขแอปที่มีอยู่ โค้ดตัวอย่างโฮสต์บน GitHub

ดาวน์โหลดโค้ด

วิธีการต่อไปนี้แสดงวิธีสร้างสำเนาตัวอย่างในเครื่อง โดยใช้เครื่องมือบรรทัดคำสั่ง git

วิธีดาวน์โหลดโค้ดตัวอย่าง

โคลนที่เก็บ Git โดยใช้คำสั่งต่อไปนี้
```
git clone https://github.com/google-ai-edge/mediapipe-samples
```
นอกจากนี้ คุณสามารถกำหนดค่าอินสแตนซ์ Git ให้ใช้การชำระเงินแบบกระจัดกระจายเพื่อให้คุณมี เฉพาะไฟล์สำหรับแอปตัวอย่าง LLM Inference API เท่านั้น
```
cd mediapipe
git sparse-checkout init --cone
git sparse-checkout set examples/llm_inference/android
```

หลังจากสร้างโค้ดตัวอย่างในเวอร์ชันในเครื่องแล้ว คุณจะนำเข้าโปรเจ็กต์ได้ ลงใน Android Studio และเรียกใช้แอป โปรดดูวิธีการในคู่มือการตั้งค่าสำหรับ Android

ตั้งค่า

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

การอ้างอิง

LLM Inference API ใช้ไลบรารี com.google.mediapipe:tasks-genai เพิ่มรายการนี้ จะขึ้นอยู่กับไฟล์ build.gradle ของแอป Android ดังนี้

dependencies {
    implementation 'com.google.mediapipe:tasks-genai:0.10.14'
}

รุ่น

MediaPipe LLM Inference API ต้องการโมเดลภาษาข้อความเป็นข้อความที่ได้รับการฝึกแล้ว เข้ากันได้กับงานนี้ หลังจากดาวน์โหลดโมเดล ให้ติดตั้ง ทรัพยากร Dependency แล้วพุชโมเดลไปยังอุปกรณ์ Android หากคุณใช้โมเดล นอกจาก Gemma คุณจะต้องแปลงโมเดลให้เป็นรูปแบบที่ใช้ได้กับ MediaPipe.

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

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

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

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

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

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

Conversion ของรูปแบบการระบุแหล่งที่มา

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

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

พุชโมเดลไปยังอุปกรณ์

พุชเนื้อหาของโฟลเดอร์ output_path ไปยัง Android อุปกรณ์

$ adb shell rm -r /data/local/tmp/llm/ # Remove any previously loaded models
$ adb shell mkdir -p /data/local/tmp/llm/
$ adb push output_path /data/local/tmp/llm/model_version.bin

สร้างงาน

MediaPipe LLM Inference API ใช้ฟังก์ชัน createFromOptions() เพื่อตั้งค่า งาน ฟังก์ชัน createFromOptions() จะยอมรับค่าสำหรับการกำหนดค่า ตัวเลือก โปรดดูข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกการกําหนดค่าได้ที่การกําหนดค่า ตัวเลือกเพิ่มเติม

โค้ดต่อไปนี้จะเริ่มต้นงานโดยใช้ตัวเลือกการกำหนดค่าพื้นฐาน

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPATH('/data/local/.../')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .build()

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

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

ใช้ตัวเลือกการกำหนดค่าต่อไปนี้เพื่อตั้งค่าแอป Android

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

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

LLM Inference API ยอมรับอินพุตต่อไปนี้

prompt (สตริง): คำถามหรือพรอมต์

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

เรียกใช้งาน

ใช้เมธอด generateResponse() เพื่อสร้างข้อความตอบกลับอินพุต ข้อความที่มีอยู่ในส่วนก่อนหน้า (inputPrompt) ฟีเจอร์นี้จะสร้างซิงเกิล คำตอบที่สร้างขึ้น

val result = llmInference.generateResponse(inputPrompt)
logger.atInfo().log("result: $result")

หากต้องการสตรีมคำตอบ ให้ใช้เมธอด generateResponseAsync()

val options = LlmInference.LlmInferenceOptions.builder()
  ...
  .setResultListener { partialResult, done ->
    logger.atInfo().log("partial result: $partialResult")
  }
  .build()

llmInference.generateResponseAsync(inputPrompt)

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

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

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 ที่ปรับแต่งอย่างละเอียด ไฟล์ Safetensor คือจุดตรวจ LoRA ที่ใช้ในการแปลงโมเดล

ในขั้นตอนถัดไป คุณต้องแปลงน้ำหนักโมเดลเป็น Flatbuffer ของ TensorFlow Lite โดยใช้แพ็กเกจ 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 เว็บรองรับ LoRA แบบไดนามิก ซึ่งเปลี่ยน LoRA รุ่นต่างๆ ในระหว่างรันไทม์ได้ Android และ iOS รองรับ LoRA แบบคงที่ ซึ่งใช้น้ำหนัก 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() เดียวกันกับโมเดลฐาน