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

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

רוצה לנסות?

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

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

תחילת העבודה

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

פרטי המשימה

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

תכונות

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

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

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

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

שם האפשרות תיאור טווח ערכים ערך ברירת מחדל
modelPath הנתיב למקום שבו המודל מאוחסן בספריית הפרויקט. נתיב לא רלוונטי
maxTokens המספר המקסימלי של אסימונים (אסימוני קלט + אסימוני פלט) שבהם המודל מטפל. מספר שלם 512
topK מספר האסימונים שהמודל משקלל בכל שלב של היצירה. מגביל את החיזויים ל-K האסימונים המובילים עם הסבירות הגבוהה ביותר. מספר שלם 40
temperature מידת הרנדומיזציה שנעשה במהלך היצירה. גבוהה יותר עוזרת ליצור יותר יצירתיות בטקסט שנוצר. טמפרטורה נמוכה יותר יוצרת יצירה צפויה יותר. Float 0.8
randomSeed המקור האקראי שבו נעשה שימוש במהלך יצירת הטקסט. מספר שלם 0
loraPath הנתיב המוחלט למודל LoRA באופן מקומי במכשיר. הערה: האפשרות הזו תואמת רק למודלים של GPU. נתיב לא רלוונטי
resultListener מגדיר את אוזן התוצאות לקבל את התוצאות באופן אסינכרוני. רלוונטי רק כשמשתמשים בשיטת היצירה האסינכרונית. לא רלוונטי לא רלוונטי
errorListener הגדרת האזנה לשגיאות אופציונלית. לא רלוונטי לא רלוונטי

דגמים

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

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

Gemma 2B

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

הורדת Gemma 2B

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

אפשר גם לכוונן את המודל ולהוסיף משקלים חדשים לפני שמוסיפים אותו לאפליקציה. עבור לקבלת מידע נוסף על כוונון והתאמה אישית של 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 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.

פרמטר תיאור ערכים קבילים
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 עובר המרה. {"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
backend המעבד (הענקת גישה) ששימש להפעלת המודל. {"cpu", "gpu"}
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 שם קובץ הפלט של חבילת המשימות. נתיב

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

מערכת Android תומכת ב-LoRA סטטית במהלך האתחול. כדי לטעון מודל LoRA, המשתמשים מציינים את הנתיב של מודל LoRA וגם את ה-LLM הבסיסי.

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