ממשק ה-API להסקת מסקנות (LLM) מאפשר לכם להריץ מודלים גדולים של שפה (LLMs) בכל המכשירים שלכם לאפליקציות ל-Android, שאפשר להשתמש בהן כדי לבצע מגוון רחב של משימות, כמו יצירת טקסט, אחזור מידע בשפה טבעית סיכום מסמכים. המשימה כוללת תמיכה מובנית בריבוי המרת טקסט לטקסט (LLM), כדי שניתן יהיה להחיל את הגרסה העדכנית ביותר במכשיר של בינה מלאכותית גנרטיבית לאפליקציות שלכם ל-Android.
המשימה תומכת ב-Gemma 2B, חלק משפחה של מודלים פתוחים מתקדמים וקלילים שנוצרו באותו מחקר והטכנולוגיה שמשמשת ליצירת המודלים של Gemini. הוא תומך גם במודלים החיצוניים הבאים: 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 נדרש מודל מאומן של שפת טקסט לטקסט, שתואמים למשימה הזו. לאחר הורדת מודל, מתקינים את של יחסי התלות ולדחוף את הדגם למכשיר ה-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.
פרמטר | תיאור | ערכים קבילים |
---|---|---|
input_ckpt |
הנתיב לקובץ model.safetensors או pytorch.bin . חשוב לשים לב שלפעמים הפורמט של אמצעי ההגנה על המודל מחולק למספר קבצים, למשל 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 |
הנתיב לקובץ ה-safetensors של LoRA שמאחסן את המשקל של מתאם LoRA. | נתיב |
lora_rank |
מספר שלם שמייצג את הדירוג של LoRA ckpt. נדרש כדי להמיר את משקולות הלורה. אם לא סופק, הממיר מניח שאין משקולות LoRA. הערה: רק הקצה העורפי של ה-GPU תומך ב-LoRA. | מספר שלם |
lora_output_tflite_file |
פלט שם קובץ 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)
פרמטר | תיאור | ערכים קבילים |
---|---|---|
tflite_model |
הנתיב למודל TFLite שמשמש לייצוא ל-AI Edge. | נתיב |
tokenizer_model |
הנתיב למודל של כלי ההמרה לאסימונים מסוג SentencePiece. | נתיב |
start_token |
אסימון התחלה ספציפי לדגם. אסימון ההתחלה חייב להיות קיים במקטע של כלי ההמרה לאסימונים. | מחרוזת |
stop_tokens |
אסימוני עצירה ספציפיים לדגם. אסימוני העצירה חייבים להיות קיימים של כלי ההמרה לאסימונים. | רשימה[STRING] |
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 |
מידת הרנדומיזציה שנעשה במהלך היצירה. גבוהה יותר עוזרת ליצור יותר יצירתיות בטקסט שנוצר. טמפרטורה נמוכה יותר יוצרת יצירה צפויה יותר. | Float | 0.8 |
randomSeed |
המקור האקראי שבו נעשה שימוש במהלך יצירת הטקסט. | מספר שלם | 0 |
loraPath |
הנתיב המוחלט למודל LoRA באופן מקומי במכשיר. הערה: האפשרות הזו תואמת רק למודלים של GPU. | נתיב | לא רלוונטי |
resultListener |
מגדיר את אוזן התוצאות לקבל את התוצאות באופן אסינכרוני. רלוונטי רק כשמשתמשים בשיטת היצירה האסינכרונית. | לא רלוונטי | לא רלוונטי |
errorListener |
הגדרת האזנה לשגיאות אופציונלית. | לא רלוונטי | לא רלוונטי |
הכנת נתונים
ממשק ה-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 לאורך כל משך המשימה.
מערכת 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()
כמו במודל הבסיס.