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

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

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

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

קוד לדוגמה

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

להורדת הקוד

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

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

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

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

2. לחלופין, להגדיר את מכונת ה-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 נדרש מודל מאומן של שפת טקסט לטקסט, שתואמים למשימה הזו. לאחר הורדת מודל, מתקינים את של יחסי התלות ולדחוף את הדגם למכשיר ה-Android. אם אתם משתמשים במודל פרט ל-Gemma, תצטרכו להמיר את המודל לפורמט שמתאים ל MediaPipe.

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

הורדת מודל

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

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

לחלופין, אפשר להשתמש במודלים שממופים ויוצאו דרך AI Edge Troch

מומלץ להשתמש ב-Gemma 2B, שזמין ב-Kaggle דגמים בפורמט שכבר תואם ל-LLM Inference API. אם משתמשים צריך להמיר את המודל פורמט ידידותי ל-MediaPipe. לקבלת מידע נוסף על Gemma 2B, כדאי לעיין במאמר Gemma . למידע נוסף על הכלי בסקירה הכללית של המשימות, תוכלו לעיין בקטע 'מודלים'.

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

המרה של מודל מותאם

אם אתם משתמשים ב-LLM חיצוני (Phi-2 , Falcon או StableLM) או של Gemma, להשתמש בסקריפטים של ההמרות כדי לעצב את המודל שתואם ל-MediaPipe.

לתהליך המרת המודל נדרשת חבילת MediaPipe PyPI. ההמרה הסקריפט יהיה זמין בכל חבילות MediaPipe אחרי 0.10.11.

מתקינים ומייבאים את יחסי התלות עם הפריטים הבאים:

$ 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, אחד לדגם הבסיסי והשני למודל LoRA.

המרת מודל של AI Edge

אם אתם משתמשים ב-LLM שממופה למודל TFLite דרך AI Edge, סקריפט מקבצים כדי ליצור חבילת משימות. תהליך הקיבוץ נכללים למודל ממופה עם מטא-נתונים נוספים (למשל, פרמטרים של אסימון (Tokenizer)) כדי להריץ מסקנות מקצה לקצה.

תהליך הארגון של המודל מחייב את חבילת MediaPipe PyPI. ההמרה הסקריפט יהיה זמין בכל חבילות MediaPipe אחרי 0.10.14.

מתקינים ומייבאים את יחסי התלות עם הפריטים הבאים:

$ 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)

דחיפת המודל למכשיר

דחיפת התוכן של התיקייה 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) מקבל את מקורות הקלט הבאים:

• 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

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

התמיכה של 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)

הממיר יפיק שני קובצי אחסון זמני של TFLite, אחד לדגם הבסיסי והשני למודל LoRA.

מסקנות ממודל LoRA

ממשקי ה-API של LLM Inference API, Android ו-iOS, מעודכנים כדי לתמוך בהסקה של מודל LoRA. באינטרנט יש תמיכה ב-LoRA דינמית, שיכולה להחליף מודלים שונים של LoRA במהלך זמן ריצה. מכשירי Android ו-iOS תומכים ב-LoRA הסטטית, שמשתמשת באותם משקלים של 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() כמו במודל הבסיס.