מדריך להסקת מסקנות LLM לאתרים

ממשק ה-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 עובר המרה. {&quot;PHI_2&quot;, &quot;FALCON_RW_1B&quot;, &quot;STABLELM_4E1T_3B&quot;, &quot;GEMMA_2B&quot;}
backend המעבד (הענקת גישה) ששימש להפעלת המודל. {&quot;cpu&quot;, &quot;gpu&quot;}
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;
});