ממשק ה-API להסקת מסקנות (LLM) מאפשר לכם להריץ מודלים גדולים של שפה (LLMs) לחלוטין לדפדפן לאפליקציות אינטרנט, שאפשר להשתמש בו כדי לבצע מגוון רחב של משימות שונות כמו יצירת טקסט, אחזור מידע בשפה טבעית, וסיכום מסמכים. המשימה כוללת תמיכה מובנית בריבוי המרת טקסט לטקסט (LLM), כדי שניתן יהיה להחיל את הגרסה העדכנית ביותר במכשיר של בינה מלאכותית גנרטיבית לאפליקציות האינטרנט שלכם.
אפשר לראות את המשימה הזו בפעולה ב-MediaPipe Studio . מידע נוסף על היכולות, המודלים ואפשרויות ההגדרה במשימה הזאת, ראו סקירה כללית.
קוד לדוגמה
האפליקציה לדוגמה של ממשק ה-API להסקת מסקנות (LLM) מספקת הטמעה בסיסית של משימה זו ב-JavaScript לעיונך. אפשר להשתמש באפליקציה לדוגמה כדי לקבל התחלתם ליצור אפליקציה משלכם ליצירת טקסט.
ניתן לגשת לאפליקציה לדוגמה של LLM Inference API דרך GitHub.
הגדרה
בקטע הזה מתוארים השלבים העיקריים להגדרת סביבת הפיתוח בפרויקטים ספציפיים לשימוש ב-LLM Inference API. למידע כללי על להגדיר את סביבת הפיתוח לשימוש ב-MediaPipe Tasks, כולל הדרישות לגרסאות הפלטפורמה זמינות במדריך ההגדרה עבור אינטרנט.
תאימות דפדפן
כדי להשתמש ב-LLM Inference API, צריך להשתמש בדפדפן אינטרנט עם תאימות ל-WebGPU. כדי לקבל רשימה של דפדפנים תואמים, ראו דפדפן GPU .
חבילות JavaScript
קוד ה-LLM Inference API זמין דרך
@mediapipe/tasks-genai
חבילה. ניתן למצוא ולהוריד את הספריות האלה בקישורים שנמצאים
מדריך ההגדרה לפלטפורמה.
מתקינים את החבילות הנדרשות להפעלת Staging מקומי:
npm install @mediapipe/tasks-genai
כדי לפרוס לשרת, צריך להשתמש בשירות להעברת תוכן (CDN), כמו jsDelivr כדי להוסיף קוד ישירות לדף ה-HTML:
<head>
<script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
crossorigin="anonymous"></script>
</head>
דגם
ל-MediaPipe LLM Inference API נדרש מודל מאומן שתואם למשימה הזו. באפליקציות אינטרנט, המודל חייב להיות תואם ל-GPU.
במשימה שכאן אפשר לקבל מידע נוסף על מודלים זמינים מאומנים של LLM Inference API סקירה כללית בקטע 'מודלים'.
הורדת מודל
לפני האתחול של LLM Inference API, צריך להוריד את אחד מהמודלים הנתמכים אחסון הקובץ בספריית הפרויקט:
- Gemma: חלק ממשפחה של דגמים קלילים וחדשניים פתוחים שנוצרו אותם המחקר והטכנולוגיה ששימשו ליצירת מודלים של Gemini. מתאים במיוחד למגוון של יצירת טקסט, כולל מענה לשאלות, סיכום הסקת מסקנות. מורידים את הווריאציה של מודל Gemma 2B או Gemma 7B.
- Phi-2: 2.7 מיליארד פרמטרים מודל טרנספורמר מתאים במיוחד לשאלות, תשובות לשאלות, צ'אט וקוד הפורמט.
- Falcon-RW-1B: מיליארד מודל סיבתי של מפענח בלבד שאומן על 350 מיליארד אסימונים של RefinedWeb.
- StableLM-3B: 3 מיליארד פרמטרים של מפענח בלבד שעבר אימון מראש על 1 טריליון במערכי נתונים מגוונים של אנגלית וקוד.
מומלץ להשתמש ב-Gemma 2B או ב-Gemma 7B, שזמינים ב-Kaggle דגמים בפורמט שכבר תואם ל-LLM Inference API. אם משתמשים צריך להמיר את המודל פורמט ידידותי ל-MediaPipe. למידע נוסף על Gemma, אפשר לעיין באתר של 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 |
שם קובץ הפלט של חבילת המשימות. | נתיב |
הוספת המודל לספריית הפרויקט
אחסון המודל בספריית הפרויקט:
<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin
ציון הנתיב של המודל עם האובייקט modelAssetPath
מסוג baseOptions
:
baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}
יצירת המשימה
משתמשים באחת מהפונקציות createFrom...()
של LLM Inference API כדי להכין את המשימה
הסקת מסקנות אפשר להשתמש בפונקציה createFromModelPath()
עם
נתיב יחסי או מוחלט לקובץ המודל שעבר אימון. דוגמת הקוד משתמשת באופרטור
createFromOptions()
. לקבלת מידע נוסף על
להגדרות אישיות, ראו אפשרויות הגדרה.
תוכלו להיעזר בקוד הבא כדי ליצור ולהגדיר את המשימה הזו:
const genai = await FilesetResolver.forGenAiTasks(
// path/to/wasm/root
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
baseOptions: {
modelAssetPath: '/assets/gemma-2b-it-gpu-int4.bin'
},
maxTokens: 1000,
topK: 40,
temperature: 0.8,
randomSeed: 101
});
אפשרויות תצורה
המשימה הזו כוללת את אפשרויות ההגדרה הבאות לאפליקציות אינטרנט ו-JavaScript:
שם האפשרות | תיאור | טווח ערכים | ערך ברירת מחדל |
---|---|---|---|
modelPath |
הנתיב למקום שבו המודל מאוחסן בספריית הפרויקט. | נתיב | לא רלוונטי |
maxTokens |
המספר המקסימלי של אסימונים (אסימוני קלט + אסימוני פלט) שבהם המודל מטפל. | מספר שלם | 512 |
topK |
מספר האסימונים שהמודל משקלל בכל שלב של היצירה. מגביל את החיזויים ל-K האסימונים המובילים עם הסבירות הגבוהה ביותר. | מספר שלם | 40 |
temperature |
מידת הרנדומיזציה שנעשה במהלך היצירה. גבוהה יותר עוזרת ליצור יותר יצירתיות בטקסט שנוצר. טמפרטורה נמוכה יותר יוצרת יצירה צפויה יותר. | Float | 0.8 |
randomSeed |
המקור האקראי שבו נעשה שימוש במהלך יצירת הטקסט. | מספר שלם | 0 |
loraRanks |
דירוגים של LoRA שישמשו את מודלים של LoRA במהלך זמן ריצה. הערה: האפשרות הזו תואמת רק למודלים של GPU. | מערך מספר שלם | לא רלוונטי |
הכנת נתונים
LLM Inference API מקבל נתוני טקסט (string
). המשימה מטפלת בקלט הנתונים
מראש, כולל יצירת אסימונים ועיבוד מראש של tensor.
כל העיבוד מראש מטופל בתוך הפונקציה generateResponse()
. יש
ואין צורך בעיבוד מראש נוסף של טקסט הקלט.
const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";
הרצת המשימה
ממשק ה-API להסקת מסקנות (LLM) משתמש בפונקציה generateResponse()
כדי להפעיל הסקת מסקנות.
לסיווג טקסט, המשמעות היא החזרת הקטגוריות האפשריות של
של טקסט הקלט.
הקוד הבא מדגים איך מבצעים את העיבוד באמצעות המשימה מודל טרנספורמר.
const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;
כדי לשדר את התשובה בסטרימינג, משתמשים בפעולות הבאות:
llmInference.generateResponse(
inputPrompt,
(partialResult, done) => {
document.getElementById('output').textContent += partialResult;
});
טיפול בתוצאות והצגתן
LLM Inference API מחזיר מחרוזת, שכוללת את טקסט התשובה שנוצר.
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 לאורך כל משך המשימה.
האינטרנט תומך ב-LoRA דינמי במהלך זמן ריצה. כלומר, המשתמשים מצהירים שישמשו את רמות LoRA במהלך האתחול, ויכולים להחליף מודלים שונים של LoRA במהלך זמן ריצה.const genai = await FilesetResolver.forGenAiTasks(
// path/to/wasm/root
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
// options for the base model
...
// LoRA ranks to be used by the LoRA models during runtime
loraRanks: [4, 8, 16]
});
במהלך זמן הריצה, אחרי אתחול המודל הבסיסי, טוענים את מודלי LoRA שבהם רוצים להשתמש. בנוסף, מפעילים את מודל LoRA על ידי העברת ההפניה של מודל LoRA בזמן יצירת התשובה ל-LLM.
// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);
// Specify LoRA model to be used during inference
llmInference.generateResponse(
inputPrompt,
loraModelRank4,
(partialResult, done) => {
document.getElementById('output').textContent += partialResult;
});