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

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

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

המשימה תומכת בגרסאות הבאות של Gemma: Gemma-3 1B,‏ Gemma-2 2B,‏ Gemma 2B ו-Gemma 7B. Gemma היא משפחה של מודלים פתוחים וקלים, מתקדמים ביותר, שנוצרו על סמך אותו מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini. הוא תומך גם בדגמים החיצוניים הבאים: Phi-2,‏ Falcon-RW-1B ו-StableLM-3B.

בנוסף למודלים הנתמכים, אפשר להשתמש ב-AI Edge Torch של Google כדי לייצא מודלים של PyTorch למודלים של LiteRT (tflite) עם חתימות מרובות, שמצורפים לפרמטרים של ה-tokenizer כדי ליצור חבילות משימות שתואמות ל-LLM Inference API. מודלים שעברו המרה באמצעות AI Edge Torch יכולים לפעול רק בקצה העורפי של המעבד, ולכן הם מוגבלים ל-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, צריך להוריד מודל ולשמור את הקובץ בספריית הפרויקט. אפשר להשתמש במודל שהומר מראש או להמיר מודל לפורמט תואם ל-MediaPipe.

ה-LLM Inference API תואם לסוגי המודלים הבאים, חלקם דורשים המרה של מודל. בטבלה הבאה מפורטות השיטות הנדרשות לכל מודל.

בקטע המרת מודלים מוסבר איך ממירים מודלים אחרים.

Gemma-3 1B

Gemma-3 1B הוא המודל החדש ביותר במשפחת Gemma של מודלים פתוחים, קלים ומתקדמים, שנוצרו על סמך אותו מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini. המודל מכיל מיליארד פרמטרים ומשקללים פתוחים. גרסת 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 הוא מודל ממשפחת Gemma של מודלים פתוחים, קלים ומתקדמים, שנוצרו על סמך אותו מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini. המודל מכיל 2 מיליארד פרמטרים ומשקללים פתוחים. Gemma-2 2B ידועה ביכולות ההסקה המתקדמות שלה, בהשוואה לדגמים אחרים באותה קטגוריה.

הורדת Gemma-2 2B

הדגמים של Gemma-2 2B זמינים באפשרויות הבאות:

• gemma2-2b-it-cpu-int8: מודל Gemma-2 2B 8-bit עם תאימות ל-CPU.
• gemma2-2b-it-gpu-int8: מודל Gemma-2 2B 8-bit עם תאימות ל-GPU.

אפשר גם לשפר את המודל ולהוסיף משקלים חדשים לפני שמוסיפים אותו לאפליקציה. מידע נוסף על שינוי והתאמה אישית של Gemma זמין במאמר שינוי והתאמה אישית של Gemma. אחרי שמורידים את Gemma-22B מ-Kaggle Models, המודל כבר בפורמט המתאים לשימוש ב-MediaPipe Tasks.

Gemma 2B

Gemma 2B הוא חלק ממשפחה של מודלים פתוחים, קלים ומתקדמים, שנוצרו על סמך אותו מחקר וטכנולוגיה ששימשו ליצירת המודלים של Gemini. המודל מכיל 2 מיליארד פרמטרים ומשקלים פתוחים. המודל הזה מתאים למגוון משימות של יצירת טקסט, כולל מענה לשאלות, סיכום ושיוך.

הורדת Gemma 2B

הדגמים של Gemma 2B זמינים באפשרויות הבאות:

• gemma-2b-it-cpu-int4: דגם Gemma 2B 4-bit עם תאימות למעבד.
• gemma-2b-it-cpu-int8: מודל Gemma 2B 8 ביט עם תאימות ל-CPU.
• gemma-2b-it-gpu-int4: דגם Gemma 2B 4-bit עם תאימות ל-GPU.
• gemma-2b-it-gpu-int8: דגם Gemma 2B 8 ביט עם תאימות ל-GPU.

אפשר גם לשפר את המודל ולהוסיף משקלים חדשים לפני שמוסיפים אותו לאפליקציה. מידע נוסף על שינוי והתאמה אישית של Gemma זמין במאמר שינוי והתאמה אישית של Gemma. אחרי שמורידים את Gemma 2B מ-Kaggle Models, המודלים כבר בפורמט המתאים לשימוש ב-MediaPipe Tasks.

Gemma 7B

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

הורדת Gemma 7B

לדגם Gemma 7B יש וריאנט אחד:

• gemma-1.1-7b-it-gpu-int8: מודל Gemma 7B בן 8 ביט עם תאימות ל-GPU.

אחרי שמורידים את Gemma 7B מ-Kaggle Models, המודל כבר נמצא בפורמט המתאים לשימוש עם MediaPipe.

Falcon 1B

Falcon-1B הוא מודל של מפענח קלוזאלי עם מיליארד פרמטרים, שאומן על 350 מיליארד אסימונים של RefinedWeb.

הורדת Falcon 1B

כדי להשתמש ב-LLM Inference API, צריך להוריד את הקבצים הבאים ולאחסן אותם באופן מקומי:

• tokenizer.json
• tokenizer_config.json
• pytorch_model.bin

אחרי הורדת קובצי המודל של Falcon, המודל מוכן להמרה לפורמט MediaPipe באמצעות סקריפט המרה. פועלים לפי השלבים שמפורטים בקטע סקריפט המרות למודלים נתמכים.

StableLM 3B

StableLM-3B הוא מודל שפה של מפענח בלבד עם 3 מיליארד פרמטרים, שעבר אימון מראש על 4 מיליארד אסימונים של מערכי נתונים מגוונים של אנגלית וקוד במשך 4 תקופות אימון (epochs).

הורדת StableLM 3B

כדי להשתמש ב-LLM Inference API, צריך להוריד את הקבצים הבאים ולאחסן אותם באופן מקומי:

• tokenizer.json
• tokenizer_config.json
• model.safetensors

אחרי הורדת קובצי המודל של StableLM, המודל מוכן להמרה לפורמט MediaPipe באמצעות סקריפט המרה. פועלים לפי השלבים שמפורטים בקטע סקריפט המרות למודלים נתמכים.

Phi-2

Phi-2 הוא מודל טרנספורמר עם 2.7 מיליארד פרמטרים. הוא אומן באמצעות טקסטים סינתטיים שונים של NLP ואתרים מסוננים. המודל מתאים במיוחד להנחיות בפורמט של שאלה-תשובה, צ'אט וקוד.

הורדת Phi-2

כדי להשתמש ב-LLM Inference API, צריך להוריד את הקבצים הבאים ולאחסן אותם באופן מקומי:

• tokenizer.json
• tokenizer_config.json
• model-00001-of-00002.safetensors
• model-00002-of-00002.safetensors

אחרי הורדת קובצי המודל של Phi-2, אפשר להמיר את המודל לפורמט של MediaPipe באמצעות סקריפט המרה. פועלים לפי השלבים שמפורטים בקטע סקריפט המרות למודלים נתמכים.

מודלים גנרטיביים של PyTorch

אפשר להמיר מודלים גנרטיביים של PyTorch לפורמט תואם ל-MediaPipe באמצעות AI Edge Torch Generative API. אפשר להשתמש ב-API כדי להמיר מודלים של PyTorch למודלים של LiteRT (TensorFlow Lite) עם חתימות מרובות. פרטים נוספים על מיפוי וייצוא מודלים זמינים בדף GitHub של AI Edge Torch.

אם אתם מתכוונים להשתמש ב-AI Edge Torch Generative API כדי להמיר מודל PyTorch, עליכם לפעול לפי השלבים שמפורטים בקטע הממיר Torch Generative למודל PyTorch.

המרה לפי מודל

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

LLM Inference API מקבל מודלים בפורמטים של קבצים .bin ו-.task. באופן כללי, מודלים שהועברו קודם לכן ומודלים שהועברו באמצעות סקריפט ההמרה יהיו קובצי .bin, ואילו מודלים שהועברו באמצעות ספריית AI Edge Torch יהיו קובצי .task. אין לשנות באופן ידני את פורמטים הקבצים של המודלים המומרים.

ממשק ה-API של LLM Inference מכיל שלושה נתיבי המרה של מודלים:

• מודלים שהועברו מראש (Gemma-3 1B, ‏ Gemma-2 2B, ‏ Gemma 2B, ‏ Gemma 7B): אין צורך בהמרה.
• מודלים נתמכים (Phi-2, ‏ StableLM, ‏ Falcon): סקריפט המרה של MediaPipe.
• מודלים אחרים של PyTorch (כל המודלים של PyTorch LLM): AI Edge Torch Generative API.

מודלים שהועברו מראש

המודלים Gemma-2 2B‏, Gemma 2B ו-Gemma 7B זמינים כמודלים שהוסבו מראש לפורמט MediaPipe. המודלים האלה לא דורשים מהמשתמשים לבצע שלבי המרה נוספים, וניתן להריץ אותם כפי שהם באמצעות LLM Inference API.

אפשר להוריד את Gemma-2 2B מ-Kaggle Models:

• gemma2-2b-it-cpu-int8: מודל Gemma-2 2B 8-bit עם תאימות ל-CPU.
• gemma2-2b-it-gpu-int8: מודל Gemma-2 2B 8-bit עם תאימות ל-GPU.

אפשר להוריד וריאנטים של Gemma 2B מ-Kaggle Models:

• gemma-2b-it-cpu-int4: דגם Gemma 2B 4-bit עם תאימות למעבד.
• gemma-2b-it-cpu-int8: מודל Gemma 2B 8 ביט עם תאימות ל-CPU.
• gemma-2b-it-gpu-int4: דגם Gemma 2B 4-bit עם תאימות ל-GPU.
• gemma-2b-it-gpu-int8: דגם Gemma 2B 8 ביט עם תאימות ל-GPU.

אפשר להוריד את Gemma 7B מ-Kaggle Models:

• gemma-1.1-7b-it-gpu-int8: מודל Gemma 7B בן 8 ביט עם תאימות ל-GPU.

מידע נוסף על המודלים של Gemma זמין במסמכי העזרה של Gemma-2 2B, Gemma 2B ו-Gemma 7B.

סקריפט המרות למודלים נתמכים

בחבילת MediaPipe יש סקריפט המרה להמרת המודלים החיצוניים הבאים לפורמט תואם ל-MediaPipe:

• Falcon 1B
• StableLM 3B
• Phi-2

מידע נוסף על המודלים החיצוניים הנתמכים זמין במסמכי העזרה של Falcon 1B,‏ StableLM 3B ו-Phi-2.

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

הממיר יפיק שני קובצי flatbuffer של TFLite, אחד למודל הבסיס והשני למודל LoRA.

Torch Generative converter למודלים של PyTorch

אפשר להמיר מודלים גנרטיביים של PyTorch לפורמט תואם ל-MediaPipe באמצעות AI Edge Torch Generative API. אפשר להשתמש ב-API כדי ליצור, להמיר ולקבוע כמות של מודלים של LLM ב-PyTorch לשימוש עם LLM Inference API. הממיר הגנרטיבי של Torch מבצע המרה רק ל-CPU, ונדרש לו מכונה עם Linux עם זיכרון RAM בנפח של 64GB לפחות.

כדי להמיר מודל PyTorch באמצעות AI Edge Torch Generative API, צריך לבצע את הפעולות הבאות:

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

כדי ליצור חבילה של משימות, משתמשים בסקריפט לאריזה כדי ליצור חבילה של משימות. תהליך הקיפול כולל את המודלים הממופים עם מטא-נתונים נוספים (למשל, 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() כמו במודל הבסיס.