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

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

רוצה לנסות?arrow_forward

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

בנוסף למודלים הנתמכים במקור, המשתמשים יכולים למפות מודלים של Google באמצעות AI Edge של Google (כולל מיפוי מודלים של PyTorch). כך המשתמשים יכולים לייצא מודל ממופה לכמה חתימות מודלים של TensorFlow Lite, שמקובצים עם פרמטרים של רכיב ההמרה לאסימונים ליצור חבילת משימות.

תחילת העבודה

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

• אתר:

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

• Android:

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

• iOS

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

פרטי המשימה

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

תכונות

ממשק ה-API להסקת מסקנות (LLM) כולל את התכונות העיקריות הבאות:

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

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

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

דגמים

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

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

Gemma 2B

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

הורדת Gemma 2B

לדגמי Gemma 2B יש ארבע וריאציות:

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

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

אם מורידים את Gemma 2B מ-Hugging פנים, חובה להמיר את המודל לפורמט ידידותי ל-MediaPipe. ממשק ה-API להסקת מסקנות (LLM) כדי להוריד את הקבצים הבאים ולהמיר אותם, צריך:

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

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 מ-Hugging Face, עליך להמיר את המודל לפורמט ידידותי ל-MediaPipe. כדי להשתמש ב-LLM Inference API, צריך להוריד ולהמיר את הקבצים הבאים:

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

פלקון 1B

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

הורדת Falcon 1B

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

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

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

StableLM 3B

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

הורדת StableLM 3B

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

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

אחרי שמורידים את קובצי המודל StableLM, המודל מוכן להמרה בפורמט MediaPipe. מבצעים את השלבים שמפורטים בקטע המרת המודל ל-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. מבצעים את השלבים שמפורטים בקטע המרת המודל ל-MediaPipe .

מודלים מיוצאים של AI Edge

AI Edge הוא מוצר של Google שמאפשר להמיר מודלים שמופו על ידי משתמשים במודלים של TensorFlow Lite עם חתימות מרובות. לפרטים נוספים על מיפוי ועל לייצוא מודלים, כדאי לבקר ב-AI Edge Torch דף GitHub.

אחרי ייצוא המודל לפורמט TFLite, המודל מוכן הומר לפורמט MediaPipe. מידע נוסף זמין במאמר המרת המודל לפורמט MediaPipe.

המרת המודל לפורמט 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.

המרת מודל של 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)

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

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