מדריך להסקת מודלים של LLM ל-Android

באמצעות LLM Inference API אפשר להריץ מודלים גדולים של שפה (LLM) באופן מלא במכשיר לאפליקציות ל-Android. אפשר להשתמש במודלים האלה לביצוע מגוון רחב של משימות, כמו יצירת טקסט, אחזור מידע בצורת שפה טבעית וסיכום מסמכים. המשימה מספקת תמיכה מובנית במספר מודלים גדולים של שפה (LLM) מסוג טקסט לטקסט, כך שתוכלו להחיל את מודלי ה-AI הגנרטיביים העדכניים ביותר במכשיר על האפליקציות שלכם ל-Android.

המשימה תומכת באפשרויות הבאות של Gemma: Gemma-2 2B,‏ Gemma 2B ו-Gemma 7B. Gemma היא משפחה של מודלים פתוחים וקלים לשימוש, שנוצרו על סמך אותו מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini. הוא תומך גם בדגמים החיצוניים הבאים: Phi-2,‏ Falcon-RW-1B ו-StableLM-3B.

בנוסף למודלים הנתמכים, המשתמשים יכולים להשתמש ב-AI Edge Torch של Google כדי לייצא מודלים של PyTorch למודלים של LiteRT (tflite) עם חתימות מרובות, שמצורפים לפרמטרים של ה-tokenizer כדי ליצור חבילות משימות שתואמות ל-LLM Inference API.

אתם יכולים לראות את המשימה הזו בפעולה בהדגמה של MediaPipe Studio. מידע נוסף על היכולות, המודלים והאפשרויות להגדרה של המשימה הזו זמין בסקירה הכללית.

קוד לדוגמה

המדריך הזה מתייחס לדוגמה לאפליקציה בסיסית ליצירת טקסט ל-Android. אפשר להשתמש באפליקציה כנקודת התחלה לאפליקציה משלכם ל-Android, או להיעזר בה כשמשנים אפליקציה קיימת. קוד הדוגמה מתארח ב-GitHub.

מורידים את הקוד

בהוראות הבאות מוסבר איך ליצור עותק מקומי של קוד הדוגמה באמצעות כלי שורת הפקודה git.

כדי להוריד את הקוד לדוגמה:

1. משכפלים את מאגר ה-git באמצעות הפקודה הבאה:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. אפשר גם להגדיר את מכונה של git כך שתשתמש ב-sparse checkout, כך שיישארו רק הקבצים של אפליקציית הדוגמה של 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'
}

במכשירים עם Android 12 (API 31) ואילך, מוסיפים את התלות בספרייה המקורית של OpenCL. מידע נוסף זמין במסמכי העזרה בנושא התג uses-native-library.

מוסיפים את תגי uses-native-library הבאים לקובץ AndroidManifest.xml:

<uses-native-library android:name="libOpenCL.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-car.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false"/>

דגם

כדי להשתמש ב-MediaPipe LLM Inference API, נדרש מודל שפה מאומן של טקסט לטקסט שתואם למשימה הזו. אחרי שמורידים מודל, מתקינים את יחסי התלות הנדרשים ומעבירים את המודל למכשיר Android. אם אתם משתמשים במודל שאינו Gemma, תצטרכו להמיר את המודל לפורמט תואם ל-MediaPipe.

מידע נוסף על מודלים מאומנים שזמינים ל-LLM Inference API זמין בקטע 'מודלים' שבסקירה הכללית של המשימה.

הורדת מודל

לפני שמפעילים את LLM Inference API, צריך להוריד אחד מהמודלים הנתמכים ולשמור את הקובץ בספריית הפרויקט:

• Gemma-2 2B: הגרסה האחרונה של משפחת הדגמים Gemma. חלק ממשפחה של מודלים פתוחים וקלים לייצור, שמבוססים על אותם מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini.
• Gemma 2B: חלק ממשפחה של מודלים פתוחים וקלים לשימוש, שנוצרו על סמך אותו מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini. מתאים למגוון משימות של יצירת טקסט, כולל מענה לשאלות, סיכום ושיוך.
• Phi-2: מודל טרנספורמר עם 2.7 מיליארד פרמטרים, שמתאים במיוחד לפורמטים של שאלות ותשובות, צ'אט וקוד.
• Falcon-RW-1B: מודל של מפענח סיבתי עם מיליארד פרמטרים, שאומן על 350 מיליארד אסימונים של RefinedWeb.
• StableLM-3B: מודל שפה של מפענח בלבד עם 3 מיליארד פרמטרים, שאומן מראש על טריליון אסימונים של מערכי נתונים מגוונים של אנגלית וקוד.

בנוסף למודלים הנתמכים, אפשר להשתמש ב-AI Edge Torch של Google כדי לייצא מודלים של PyTorch למודלים של LiteRT (tflite) עם חתימות מרובות. מידע נוסף זמין במאמר ממיר גנרטיבי של Torch למודלים של PyTorch.

מומלץ להשתמש ב-Gemma-2 2B, שזמין ב-Kaggle Models. מידע נוסף על המודלים האחרים הזמינים זמין בקטע 'מודלים' בסקירה הכללית של המשימה.

המרת המודל לפורמט של MediaPipe

ה-LLM Inference API תואם לשתי קטגוריות של מודלים, חלק מהן מחייבות המרה של המודל. בטבלה הבאה מפורטות השיטות הנדרשות לכל מודל.

אנחנו מארחים את קובצי ה-.bin המומרים של Gemma 2B,‏ Gemma 7B ו-Gemma-2 2B ב-Kaggle. אפשר לפרוס את המודלים האלה ישירות באמצעות LLM Inference API. בקטע המרת מודלים מוסבר איך ממירים מודלים אחרים.

העברת מודל למכשיר

מעבירים את התוכן של התיקייה 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:

הכנת הנתונים

ה-API של LLM Inference מקבל את הקלטות הבאות:

• 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, שכולל את הטקסט של התגובה שנוצר.

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 ובמודלים של Phi-2 לקצה העורפי של GPU, כאשר משקלי LoRA רלוונטיים לשכבות תשומת הלב בלבד. ההטמעה הראשונית הזו משמשת כ-API ניסיוני לפיתוח עתידי, ואנחנו מתכננים להוסיף תמיכה במודלים נוספים ובסוגי שכבות שונים בעדכונים הבאים.

הכנת מודלים של LoRA

פועלים לפי ההוראות ב-HuggingFace כדי לאמן מודל LoRA מותאם אישית במערך הנתונים שלכם עם סוגי המודלים הנתמכים, Gemma או Phi-2. המודלים Gemma-2 2B, ‏ Gemma 2B ו-Phi-2 זמינים ב-HuggingFace בפורמט safetensors. מאחר ש-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 שמשמש להמרת המודל.

בשלב הבא, צריך להמיר את משקלי המודל ל-Flatbuffer של TensorFlow Lite באמצעות חבילת Python של MediaPipe. בשדה 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, אחד למודל הבסיס והשני למודל LoRA.

הסקת מודל LoRA

ממשקי ה-API של LLM Inference לאינטרנט, ל-Android ול-iOS עודכנו כדי לתמוך בהסקת מודלים של LoRA.

// 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() כמו במודל הבסיס.