באמצעות LLM Inference API אפשר להריץ מודלים גדולים של שפה (LLM) לגמרי במכשיר, ולהשתמש בהם לביצוע מגוון רחב של משימות, כמו יצירת טקסט, אחזור מידע בצורת שפה טבעית וסיכום מסמכים. המשימה מספקת תמיכה מובנית במספר מודלים גדולים של שפה (LLM) מסוג טקסט לטקסט, כך שתוכלו להחיל את מודלי ה-AI הגנרטיביים העדכניים ביותר במכשיר על האפליקציות והמוצרים שלכם.
המשימה מספקת תמיכה מובנית במגוון מודלים גדולים של שפה (LLMs). מודלים שמתארחים בדף LiteRT Community זמינים בפורמט שמתאים ל-MediaPipe, ולא נדרשים שלבים נוספים של המרה או הידור.
אפשר להשתמש ב-AI Edge Torch כדי לייצא מודלים של PyTorch למודלים של LiteRT (tflite
) עם חתימות מרובות, שמצורפים לפרמטרים של ה-tokenizer כדי ליצור חבילות משימות. מודלים שעברו המרה באמצעות AI Edge Torch תואמים ל-LLM Inference API ויכולים לפעול בקצה העורפי של המעבד, ולכן הם מתאימים לאפליקציות ל-Android ול-iOS.
שנתחיל?
כדי להתחיל להשתמש במשימה הזו, פועלים לפי אחד מהמדריכים הבאים להטמעה בפלטפורמת היעד. במדריכים הספציפיים לפלטפורמות האלה מוסבר איך מטמיעים את המשימה הזו, עם דוגמאות קוד שמשתמשות במודל זמין ובאפשרויות ההגדרה המומלצות:
אינטרנט:
Android:
iOS
פרטי המשימה
בקטע הזה מוסבר על היכולות, הקלטים, הפלט ואפשרויות ההגדרה של המשימה הזו.
תכונות
ה-LLM Inference API כולל את התכונות העיקריות הבאות:
- יצירת טקסט מטקסט – יצירת טקסט על סמך הנחיה בטקסט להזנת קלט.
- בחירת LLM – שימוש במספר מודלים כדי להתאים אישית את האפליקציה לתרחישים הספציפיים לדוגמה. אפשר גם לאמן מחדש את המודל ולהחיל משקלים מותאמים אישית עליו.
- תמיכה ב-LoRA – אפשר להרחיב ולהתאים אישית את יכולת ה-LLM באמצעות מודל LoRA, על ידי אימון על כל מערך הנתונים או על ידי שימוש במודלים מוכנים מראש של LoRA מהקהילה של קוד פתוח (לא תואם למודלים שהועברו באמצעות AI Edge Torch Generative API).
קלט של משימות | פלט של משימות |
---|---|
ממשק ה-API של LLM Inference מקבל את הקלטות הבאות:
|
ממשק ה-API של LLM Inference מניב את התוצאות הבאות:
|
אפשרויות הגדרה
למשימה הזו יש את אפשרויות ההגדרה הבאות:
שם האפשרות | תיאור | טווח ערכים | ערך ברירת מחדל |
---|---|---|---|
modelPath |
הנתיב שבו המודל מאוחסן בתוך ספריית הפרויקט. | PATH | לא רלוונטי |
maxTokens |
המספר המקסימלי של אסימונים (אסימוני קלט + אסימוני פלט) שהמודל מטפל בהם. | מספר שלם | 512 |
topK |
מספר האסימונים שהמודל מתייחס אליהם בכל שלב של היצירה. הגבלת התחזיות ל-k האסימונים האפשריים הטובים ביותר. | מספר שלם | 40 |
temperature |
מידת האקראיות שנוספה במהלך היצירה. טמפרטורה גבוהה יותר מובילה ליצירת טקסט יצירתי יותר, ואילו טמפרטורה נמוכה יותר מובילה ליצירת טקסט צפוי יותר. | מספר ממשי (float) | 0.8 |
randomSeed |
המקור האקראי שמשמש ליצירת הטקסט. | מספר שלם | 0 |
loraPath |
הנתיב המוחלט למודל LoRA באופן מקומי במכשיר. הערה: האפשרות הזו תואמת רק לדגמי GPU. | PATH | לא רלוונטי |
resultListener |
הגדרת מאזין התוצאות לקבלת התוצאות באופן אסינכרוני. רלוונטי רק כשמשתמשים בשיטת היצירה האסינכרונית. | לא רלוונטי | לא רלוונטי |
errorListener |
הגדרת מאזין אופציונלי לשגיאות. | לא רלוונטי | לא רלוונטי |
דגמים
LLM Inference API תומך במודלים גדולים רבים של שפה (LLM) מסוג טקסט לטקסט, כולל תמיכה מובנית בכמה מודלים שעברו אופטימיזציה לצורך הפעלה בדפדפנים ובמכשירים ניידים. אפשר להשתמש במודלים הקלים האלה כדי להריץ מסקנות לגמרי במכשיר.
לפני שמפעילים את LLM Inference API, צריך להוריד מודל ולשמור את הקובץ בספריית הפרויקט. אפשר להשתמש במודל שהומר מראש מהמאגר של HuggingFace ב-LiteRT Community, או להמיר מודל לפורמט תואם ל-MediaPipe באמצעות AI Edge Torch Generative Converter.
אם עדיין אין לכם LLM לשימוש עם LLM Inference API, תוכלו להתחיל עם אחד מהמודלים הבאים.
Gemma-3 1B
Gemma-3 1B הוא המודל העדכני ביותר במשפחת Gemma של מודלים פתוחים, קלים ומתקדמים, שנוצרו על סמך אותם מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini. המודל מכיל 1 מיליארד פרמטרים ומשקללים פתוחים. גרסת 1B היא הדגם הקל ביותר במשפחת Gemma, ולכן היא אידיאלית לתרחישי שימוש רבים במכשיר.
המודל Gemma-3 1B מ-HuggingFace זמין בפורמט .task
ומוכן לשימוש עם LLM Inference API לאפליקציות ל-Android ולאינטרנט.
כשמריצים את Gemma-3 1B עם LLM Inference API, צריך להגדיר את האפשרויות הבאות בהתאם:
preferredBackend
: אפשרות לבחירה בין קצה עורפי מסוגCPU
אוGPU
. האפשרות הזו זמינה רק ל-Android.supportedLoraRanks
: לא ניתן להגדיר את LLM Inference API כך שיתמוך בהתאמה ברמה נמוכה (LoRA) עם המודל Gemma-3 1B. אין להשתמש באפשרויותsupportedLoraRanks
אוloraRanks
.maxTokens
: הערך שלmaxTokens
חייב להתאים לגודל ההקשר שמוטמע במודל. אפשר גם להתייחס לזה כמטמון של מפתח/ערך (KV) או באורך ההקשר.numResponses
: הערך חייב להיות 1 תמיד. האפשרות הזו זמינה רק לאינטרנט.
כשמריצים את Gemma-3 1B באפליקציות אינטרנט, האינטראקציה הראשונית יכולה לגרום לחסימה ממושכת של השרשור הנוכחי. אם אפשר, תמיד כדאי להריץ את המודל מתוך שרשור של עובד.
Gemma-2 2B
Gemma-2 2B היא וריאנט 2B של Gemma-2, והיא פועלת בכל הפלטפורמות.
המודל מכיל 2 מיליארד פרמטרים ומשקלים פתוחים. Gemma-2 2B ידועה ביכולות ההסקה המתקדמות שלה, בהשוואה לדגמים אחרים באותה קטגוריה.
המרת מודל PyTorch
אפשר להמיר מודלים גנרטיביים של PyTorch לפורמט תואם ל-MediaPipe באמצעות AI Edge Torch Generative API. אפשר להשתמש ב-API כדי להמיר מודלים של PyTorch למודלים של LiteRT (TensorFlow Lite) עם חתימות מרובות. פרטים נוספים על מיפוי וייצוא מודלים זמינים בדף GitHub של AI Edge Torch.
כדי להמיר מודל PyTorch באמצעות AI Edge Torch Generative API, מבצעים את השלבים הבאים:
- מורידים את נקודות הבדיקה של מודל PyTorch.
- משתמשים ב-AI Edge Torch Generative API כדי ליצור, להמיר ולקבוע את רמת הבינארי של המודל לפורמט קובץ תואם ל-MediaPipe (
.tflite
). - יוצרים חבילה של משימות (
.task
) מקובץ tflite וממקודד המודל.
הממיר הגנרטיבי של Torch מבצע המרה רק ל-CPU, ונדרש לו מכונה עם Linux עם זיכרון RAM בנפח של 64GB לפחות.
כדי ליצור חבילה של משימות, משתמשים בסקריפט לאריזה כדי ליצור חבילה של משימות. תהליך הקיפול כולל את המודלים הממופים עם מטא-נתונים נוספים (למשל, Tokenizer Parameters) שנדרשים להפעלת הסקת מסקנות מקצה לקצה.
תהליך הקיפול של המודל מחייב את חבילת 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. | PATH |
tokenizer_model |
הנתיב למודל הניתוח של SentencePiece. | PATH |
start_token |
אסימון התחלה ספציפי למודל. אסימון ההתחלה חייב להופיע במודל הניתוח של מחרוזות (tokenizer) שסופק. | מחרוזת |
stop_tokens |
אסימוני עצירה ספציפיים לדגם. אסימוני העצירה חייבים להופיע במודל הניתוח של מחרוזות הטקסט שסופק. | LIST[STRING] |
output_filename |
השם של קובץ החבילה של משימת הפלט. | PATH |
התאמה אישית של 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.
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()
כמו במודל הבסיס.