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

‫LLM Inference API מאפשר להריץ מודלים גדולים של שפה (LLM) באופן מלא במכשיר. אפשר להשתמש בו כדי לבצע מגוון רחב של משימות, כמו יצירת טקסט, אחזור מידע בצורה של שפה טבעית וסיכום מסמכים. המשימה מספקת תמיכה מובנית במודלים גדולים של שפה (LLM) להמרת טקסט לטקסט, כך שתוכלו להחיל את המודלים העדכניים ביותר של AI גנרטיבי במכשיר על האפליקציות והמוצרים שלכם.

רוצים לנסות?arrow_forward

המשימה מספקת תמיכה מובנית במגוון מודלים גדולים של שפה (LLM). מודלים שמתארחים בדף LiteRT Community זמינים בפורמט שמתאים ל-MediaPipe, ולא נדרשים שלבי המרה או קומפילציה נוספים.

אתם יכולים להשתמש ב-AI Edge Torch כדי לייצא מודלים של PyTorch למודלים של LiteRT עם חתימה מרובה (tflite), שמצורפים אליהם פרמטרים של טוקנייזר כדי ליצור חבילות משימות. מודלים שהומרו באמצעות AI Edge Torch תואמים ל-LLM Inference API ויכולים לפעול ב-CPU backend, ולכן הם מתאימים לאפליקציות ל-Android ול-iOS.

שנתחיל?

כדי להתחיל להשתמש במשימה הזו, צריך לפעול לפי אחד ממדריכי ההטמעה האלה בהתאם לפלטפורמת היעד שלכם. במדריכים הספציפיים לפלטפורמה מוסבר איך לבצע הטמעה בסיסית של המשימה הזו, עם דוגמאות קוד שמשתמשות במודל זמין ובאפשרויות ההגדרה המומלצות:

• אינטרנט:

  • מדריך
  • קוד לדוגמה

• Android:

  • מדריך
  • קוד לדוגמה

• iOS

  • מדריך
  • קוד לדוגמה

פרטי המשימה

בקטע הזה מוסבר על היכולות, הקלטים, הפלטים ואפשרויות ההגדרה של המשימה הזו.

תכונות

התכונות העיקריות של LLM Inference API הן:

1. יצירת טקסט על סמך טקסט – יצירת טקסט על סמך הנחיה טקסטואלית.
2. בחירת LLM – אפשר להחיל כמה מודלים כדי להתאים את האפליקציה לתרחישים הספציפיים שלכם. אפשר גם לאמן מחדש את המודל ולהחיל עליו משקלים בהתאמה אישית.
3. תמיכה ב-LoRA – אפשר להרחיב ולהתאים אישית את היכולות של מודל שפה גדול (LLM) באמצעות מודל LoRA. אפשר לאמן את המודל על כל מערך הנתונים שלכם, או להשתמש במודלים מוכנים מראש של LoRA מקהילת הקוד הפתוח (לא תואם למודלים שהומרו באמצעות AI Edge Torch Generative API).

אפשרויות הגדרה

אלה אפשרויות ההגדרה של המשימה:

דגמים

ה-API של LLM Inference תומך במודלים גדולים רבים של שפה (LLM) מסוג טקסט לטקסט, כולל תמיכה מובנית בכמה מודלים שעברו אופטימיזציה להפעלה בדפדפנים ובמכשירים ניידים. אפשר להשתמש במודלים הקלים האלה כדי להריץ מסקנות באופן מלא במכשיר.

לפני שמפעילים את LLM Inference API, צריך להוריד מודל ולאחסן את הקובץ בספריית הפרויקט. אפשר להשתמש במודל שעבר המרה מראש ממאגר LiteRT Community ב-HuggingFace, או להמיר מודל לפורמט שתואם ל-MediaPipe באמצעות AI Edge Torch Generative Converter.

אם עדיין אין לכם מודל LLM לשימוש עם LLM Inference API, תוכלו להתחיל עם אחד מהמודלים הבאים.

Gemma-3n

‫Gemma-3n E2B ו-E4B הם המודלים העדכניים ביותר בסדרת Gemma של מודלים קלים ומתקדמים בקוד פתוח, שמבוססים על אותם מחקרים וטכנולוגיות ששימשו ליצירת מודלי Gemini. מודלים של Gemma 3n מיועדים לביצוע יעיל במכשירים עם משאבים מוגבלים. הם יכולים לקבל קלט מולטי-מודאלי, לעבד קלט של טקסט, תמונות ואודיו, וליצור פלט של טקסט.

מודלים של Gemma 3n משתמשים בטכנולוגיית הפעלה סלקטיבית של פרמטרים כדי לצמצם את דרישות המשאבים. הטכניקה הזו מאפשרת למודלים לפעול בגודל יעיל של 2 מיליארד ו-4 מיליארד פרמטרים, שהוא נמוך ממספר הפרמטרים הכולל שהם מכילים

הורדת Gemma-3n E2B

Download Gemma-3n E4B

מודלי Gemma-3n E2B ו-E4B של HuggingFace זמינים בפורמט .litertlm ומוכנים לשימוש עם LLM Inference API ל-Android ולאינטרנט.

Gemma-3 1B

‫Gemma-3 1B הוא המודל הקל ביותר במשפחת Gemma של מודלים פתוחים קלים ומתקדמים, שנבנו על בסיס אותם מחקרים וטכנולוגיות ששימשו ליצירת מודלי Gemini. המודל מכיל מיליארד פרמטרים ומשקלים פתוחים.

הורדת Gemma-3 1B

מודל Gemma-3 1B מ-HuggingFace זמין בפורמט .task/.litertlm ומוכן לשימוש עם LLM Inference API לאפליקציות ל-Android ולאינטרנט.

כשמריצים את Gemma-3 1B עם LLM Inference API, צריך להגדיר את האפשרויות הבאות בהתאם:

• ‫preferredBackend: משתמשים באפשרות הזו כדי לבחור בין קצה עורפי מסוג CPU או GPU. האפשרות הזו זמינה רק ב-Android.
• ‫supportedLoraRanks: אי אפשר להגדיר את LLM Inference API כך שיתמוך ב-Low-Rank Adaptation ‏ (LoRA) עם מודל Gemma-3 1B. אל תשתמשו באפשרויות supportedLoraRanks או loraRanks.
• ‫maxTokens: הערך של maxTokens צריך להיות זהה לגודל ההקשר שמוטמע במודל. אפשר גם להתייחס לזה כאל מטמון של זוגות מפתח/ערך (KV) או אורך ההקשר.
• numResponses: תמיד צריך להיות 1. האפשרות הזו זמינה רק באינטרנט.

כשמריצים את Gemma-3 1B באפליקציות אינטרנט, האתחול עלול לגרום לחסימה ארוכה בשרשור הנוכחי. אם אפשר, תמיד מריצים את המודל מ-worker thread.

‫Gemma-2 2B

‫Gemma-2 2B הוא וריאציה של Gemma-2 עם 2B פרמטרים, והוא פועל בכל הפלטפורמות.

הורדת Gemma-2 2B

המודל מכיל 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, צריך לבצע את השלבים הבאים:

1. מורידים את נקודות הבדיקה של מודל PyTorch.
2. משתמשים ב-AI Edge Torch Generative API כדי ליצור, להמיר ולכמת את המודל לפורמט קובץ שתואם ל-MediaPipe ‏ (.tflite).
3. יוצרים חבילת משימות (.task/.litertlm) מקובץ ה-tflite ומאסימון המודל.

הכלי Torch Generative converter ממיר רק עבור CPU ודורש מכונת Linux עם לפחות 64GB של RAM.

כדי ליצור חבילת משימות, משתמשים בסקריפט ליצירת חבילות כדי ליצור חבילת משימות. תהליך הצירוף אורז את המודל הממופה עם מטא-נתונים נוספים (למשל, פרמטרים של טוקנייזר) שנדרשים להפעלת הסקה מקצה לקצה.

תהליך חבילת המודל דורש את חבילת 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)

התאמה אישית של LoRA

התמיכה ב-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 שמשמשת בהמרת המודל.

בשלב הבא, צריך להמיר את משקלי המודל ל-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 flatbuffer, אחד למודל הבסיס ואחד למודל LoRA.

היקש של מודל LoRA

ה-API של LLM Inference ל-Web, ל-Android ול-iOS עודכן כדי לתמוך בהסקת מסקנות של מודל LoRA.

// 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() כמו במודל הבסיסי.