ממשק ה-API להסקת מסקנות (LLM) מאפשר להריץ מודלים גדולים של שפה (LLMs) באופן מלא במכשיר, ואפשר להשתמש בו כדי לבצע מגוון רחב של משימות, יצירת טקסט, אחזור מידע בשפה טבעית, סיכום מסמכים. המשימה כוללת תמיכה מובנית בריבוי המרת טקסט לטקסט (LLM), כדי שניתן יהיה להחיל את הגרסה העדכנית ביותר במכשיר ולהתאים אותם אישית לאפליקציות ולמוצרים שלכם.
המשימה תומכת במודלים של Gemma 2B ו-7B, משפחה של דגמים קלים וחדשניים שנוצרו המחקר והטכנולוגיה שמשמשים ליצירת Gemini למשימות ספציפיות. הוא תומך גם במודלים החיצוניים הבאים: Phi-2, Falcon-RW-1B וגם StableLM-3B.
בנוסף למודלים הנתמכים במקור, המשתמשים יכולים למפות מודלים של Google באמצעות AI Edge של Google (כולל מיפוי מודלים של PyTorch). כך המשתמשים יכולים לייצא מודל ממופה לכמה חתימות מודלים של TensorFlow Lite, שמקובצים עם פרמטרים של רכיב ההמרה לאסימונים ליצור חבילת משימות.
תחילת העבודה
כדי להתחיל להשתמש במשימה הזאת תוכלו להיעזר באחד ממדריכי ההטמעה הבאים: פלטפורמת היעד. המדריכים האלה, שספציפיים לפלטפורמה, ידריכו אותך במשימה הזו, באמצעות דוגמאות קוד שמשתמשות במודל זמין אפשרויות ההגדרה המומלצות:
פרטי המשימה
בקטע הזה מתוארים היכולות, הקלט, הפלט וההגדרות האישיות לביצוע המשימה הזו.
תכונות
ממשק ה-API להסקת מסקנות (LLM) כולל את התכונות העיקריות הבאות:
- יצירת טקסט לטקסט – יצירת טקסט על סמך הנחיה להזנת טקסט.
- בחירת מודלים גדולים של שפה – משתמשים בכמה מודלים כדי להתאים את האפליקציה לצרכים שלכם במקרים ספציפיים. תוכלו גם לאמן מחדש ולהחיל משקולות מותאמות אישית מודל טרנספורמר.
- תמיכה של LoRA – הרחבה והתאמה אישית של היכולת של מודל שפה גדול (LLM) באמצעות מודל LoRA באמצעות אימון על כל מערך הנתונים, או על ידי שימוש ב-LoRA המוכנה מראש מקהילת הקוד הפתוח (מודלים מותאמים בלבד).
קלט למשימות | הפלט של המשימות |
---|---|
ממשק ה-API להסקת מסקנות (LLM) מקבל את מקורות הקלט הבאים:
|
ממשק ה-API להסקת מסקנות (LLM) מפיק את התוצאות הבאות:
|
אפשרויות הגדרות אישיות
המשימה הזו כוללת את אפשרויות ההגדרה האלה:
שם האפשרות | תיאור | טווח ערכים | ערך ברירת מחדל |
---|---|---|---|
modelPath |
הנתיב למקום שבו המודל מאוחסן בספריית הפרויקט. | נתיב | לא רלוונטי |
maxTokens |
המספר המקסימלי של אסימונים (אסימוני קלט + אסימוני פלט) שבהם המודל מטפל. | מספר שלם | 512 |
topK |
מספר האסימונים שהמודל משקלל בכל שלב של היצירה. מגביל את החיזויים ל-K האסימונים המובילים עם הסבירות הגבוהה ביותר. | מספר שלם | 40 |
temperature |
מידת הרנדומיזציה שנעשה במהלך היצירה. גבוהה יותר עוזרת ליצור יותר יצירתיות בטקסט שנוצר. טמפרטורה נמוכה יותר יוצרת יצירה צפויה יותר. | Float | 0.8 |
randomSeed |
המקור האקראי שבו נעשה שימוש במהלך יצירת הטקסט. | מספר שלם | 0 |
loraPath |
הנתיב המוחלט למודל LoRA באופן מקומי במכשיר. הערה: האפשרות הזו תואמת רק למודלים של GPU. | נתיב | לא רלוונטי |
resultListener |
מגדיר את אוזן התוצאות לקבל את התוצאות באופן אסינכרוני. רלוונטי רק כשמשתמשים בשיטת היצירה האסינכרונית. | לא רלוונטי | לא רלוונטי |
errorListener |
הגדרת האזנה לשגיאות אופציונלית. | לא רלוונטי | לא רלוונטי |
דגמים
ממשק ה-API להסקת מסקנות (LLM) כולל תמיכה מובנית בפיצול טקסט לטקסט שעברו אופטימיזציה להפעלה בדפדפנים ובמכשירים ניידים. האלה ניתן להוריד מודלים קלים כדי להריץ הסקת מסקנות במכשיר.
לפני האתחול של LLM Inference API, צריך להוריד את אחד מהמודלים הנתמכים לאחסן את הקובץ בספריית הפרויקט.
Gemma 2B
Gemma 2B היא חלק ממשפחה של מודלים פתוחים מתקדמים וקלילים המבוססים על אותו מחקר שמשמשת ליצירת המודלים של Gemini. מכיל 2B פרמטרים ומשקולות פתוחות. המודל הזה מתאים במיוחד מגוון משימות של יצירת טקסט, כולל מענה לשאלות, סיכום, והסקת מסקנות.
לדגמי Gemma 2B יש ארבע וריאציות:
- gemma-2b-it-cpu-int4: מודל 4 ביט מסוג Gemma 2B עם תאימות למעבד.
- gemma-2b-it-cpu-int8: מודל 8 ביט מסוג Gemma 2B עם תאימות למעבד.
- gemma-2b-it-gpu-int4: מודל Gemma 2B של 4 ביט עם תאימות ל-GPU.
- gemma-2b-it-gpu-int8: מודל Gemma 2B של 8 ביט עם תאימות ל-GPU.
אפשר גם לכוונן את המודל ולהוסיף משקלים חדשים לפני שמוסיפים אותו לאפליקציה. עבור לקבלת מידע נוסף על כוונון והתאמה אישית של Gemma, אפשר לעיין ב-Tuning Gemma. אחרי שמורידים את Gemma מדגמים של Kaggle, שהמודל כבר בפורמט המתאים לשימוש עם MediaPipe.
אם מורידים את Gemma 2B מ-Hugging פנים, חובה להמיר את המודל לפורמט ידידותי ל-MediaPipe. ממשק ה-API להסקת מסקנות (LLM) כדי להוריד את הקבצים הבאים ולהמיר אותם, צריך:
model-00001-of-00002.safetensors
model-00002-of-00002.safetensors
tokenizer.json
tokenizer_config.json
Gemma 7B
Gemma 7B הוא מודל Gemma גדול יותר בגודל 7B ומשקולות פתוחות. המודל חזק יותר למגוון טקסטים ליצירת משימות, כולל מענה לשאלות, סיכום והסקת מסקנות. יש תמיכה ב-Gemma 7B רק בדפדפן.
מודל Gemma 7B מגיע בווריאנט אחד:
- gemma-1.1-7b-it-gpu-int8: מודל Gemma 7B של 8 ביט עם תאימות ל-GPU.
אם מורידים את Gemma 7B מ-Hugging Face, עליך להמיר את המודל לפורמט ידידותי ל-MediaPipe. כדי להשתמש ב-LLM Inference API, צריך להוריד ולהמיר את הקבצים הבאים:
model-00001-of-00004.safetensors
model-00002-of-00004.safetensors
model-00003-of-00004.safetensors
model-00004-of-00004.safetensors
tokenizer.json
tokenizer_config.json
פלקון 1B
Falcon-1B הוא מודל של מיליארד פרמטרים למפענח בלבד שאומן לפי 350B אסימונים של RefinedWeb.
צריך להוריד ולאחסן את הקבצים הבאים ב-LLM Inference API מקומית:
tokenizer.json
tokenizer_config.json
pytorch_model.bin
אחרי שמורידים את קובצי מודל ה-Falcon, המודל מוכן להמרה בפורמט MediaPipe. מבצעים את השלבים שמפורטים בקטע המרת המודל ל-MediaPipe .
StableLM 3B
StableLM-3B הוא מודל שפה של 3 מיליארד פרמטרים ממפענח בלבד שעבר אימון מראש על 1 טריליון אסימונים של מערכי נתונים מגוונים של אנגלית וקודים במשך 4 תקופות של זמן מערכת.
צריך להוריד ולאחסן את הקבצים הבאים ב-LLM Inference API מקומית:
tokenizer.json
tokenizer_config.json
model.safetensors
אחרי שמורידים את קובצי המודל StableLM, המודל מוכן להמרה בפורמט MediaPipe. מבצעים את השלבים שמפורטים בקטע המרת המודל ל-MediaPipe .
Phi-2
Phi-2 הוא מודל טרנספורמר של 2.7 מיליארד פרמטרים. הוא אומן לפי טקסטים סינתטיים מסוג NLP ואתרים מסוננים. המודל הכי מתאים להנחיות באמצעות 'תשובה לשאלה', 'צ'אט' ו'פורמט קוד'.
צריך להוריד ולאחסן את הקבצים הבאים ב-LLM Inference API מקומית:
tokenizer.json
tokenizer_config.json
model-00001-of-00002.safetensors
model-00002-of-00002.safetensors
אחרי שמורידים את קובצי המודל Phi-2, המודל מוכן להמרה בפורמט MediaPipe. מבצעים את השלבים שמפורטים בקטע המרת המודל ל-MediaPipe .
מודלים מיוצאים של AI Edge
AI Edge הוא מוצר של Google שמאפשר להמיר מודלים שמופו על ידי משתמשים במודלים של TensorFlow Lite עם חתימות מרובות. לפרטים נוספים על מיפוי ועל לייצוא מודלים, כדאי לבקר ב-AI Edge Torch דף GitHub.
אחרי ייצוא המודל לפורמט TFLite, המודל מוכן הומר לפורמט MediaPipe. מידע נוסף זמין במאמר המרת המודל לפורמט MediaPipe.
המרת המודל לפורמט 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 |
שם קובץ הפלט של חבילת המשימות. | נתיב |
התאמה אישית של 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()
כמו במודל הבסיס.