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

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

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

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

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

שנתחיל?

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

• אינטרנט:

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

• Android:

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

• iOS

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

פרטי המשימה

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

תכונות

ה-LLM Inference API כולל את התכונות העיקריות הבאות:

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

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

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

דגמים

‏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

המודל 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, והיא פועלת בכל הפלטפורמות.

הורדת 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) מקובץ 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)

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

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

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