מידע נוסף על ההודעות מכנס I/O של Google AI Edge

דף זה תורגם על ידי Cloud Translation API.

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

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

כדאי לנסות!

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

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

מתחילים

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

פרטי המשימה

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

תכונות

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

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

קלט למשימות	פלט המשימות
ה-LLM Inference API מקבל את מקורות הקלט הבאים: הנחיה בטקסט (למשל: שאלה, נושא האימייל, מסמך לסיכום)	ה-LLM Inference API מפיק את התוצאות הבאות: טקסט שנוצר על סמך ההנחיה לקלט (למשל, תשובה לשאלה, טיוטה של אימייל, סיכום של המסמך)

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

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

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

דגמים

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

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

מיכל 2

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

להורדת Gemma 2B

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

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

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

אם מורידים את Gemma 2B מ-Hucking Face, צריך להמיר את המודל לפורמט ידידותי ל-MediaPipe. כדי להשתמש ב-LLM Inference API, צריך להוריד ולהמיר את הקבצים הבאים:

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: מודל 8 ביט של Gemma 7B עם תאימות ל-GPU.

אם מורידים את Gemma 7B מ-Hucking 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 הוא מודל של מפענח סיבתי באורך מיליארד פרמטרים, שאומן על 350 מיליארד אסימונים של RefinedWeb.

להורדת Falcon 1B

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

tokenizer.json
tokenizer_config.json
pytorch_model.bin

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

יציבLM 3B

StableLM-3B הוא מודל שפה של 3 מיליארד פרמטרים של מקודד-מפענח בלבד, שעבר אימון על טריליון אסימונים ממגוון מערכי נתונים של אנגלית וקוד, במהלך 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 בעלי חתימה מרובה. לפרטים נוספים על מיפוי וייצוא של מודלים, ראו דף GitHub על ידי AI Edge Torch.

אחרי שמייצאים את המודל לפורמט 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`. חשוב לשים לב שלפעמים הפורמט של פריטי ה-safetensors מחולקים למספר קבצים, למשל `model-00001-of-00003.safetensors`, `model-00001-of-00003.safetensors`. אפשר לציין תבנית של קובץ, כמו `model*.safetensors`.	PATH
`ckpt_format`	פורמט הקובץ של המודל.	{"safetensors", "pytorch"}
`model_type`	ה-LLM עובר המרה.	{"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
`backend`	המעבד (הגישה) ששימש להפעלת המודל.	{"cpu", "gpu"}
`output_dir`	הנתיב לספריית הפלט שמארחת את קובצי המשקל לכל שכבה.	PATH
`output_tflite_file`	הנתיב לקובץ הפלט. לדוגמה, "model_cpu.bin" או "model_gpu.bin". הקובץ הזה תואם רק ל-LLM Inference API, ואי אפשר להשתמש בו כקובץ 'tflite' כללי.	PATH
`vocab_model_file`	הנתיב לספרייה שמאחסנת את הקבצים `tokenizer.json` ו-`tokenizer_config.json`. עבור Gemma, מצביעים על הקובץ `tokenizer.model` היחיד.	PATH
`lora_ckpt`	הנתיב לקובץ Safetensors של LoRA ששומר את משקל המתאם של LoRA.	PATH
`lora_rank`	מספר שלם שמייצג את הדירוג של LoRA ckpt. נדרש כדי להמיר את משקולות הלורה. אם לא מציינים את הפרמטר הזה, הממיר מניח שאין משקלי LoRA. הערה: רק הקצה העורפי של ה-GPU תומך ב-LoRA.	מספר שלם
`lora_output_tflite_file`	שם קובץ tflite של הפלט של המשקולות של LoRA.	PATH

המרה של מודל AI Edge

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

תהליך קיבוץ המודלים מחייב חבילת 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.	PATH
`tokenizer_model`	הנתיב למודל האסימונים של SentencePiece.	PATH
`start_token`	אסימון התחלה ספציפי לדגם. אסימון ההתחלה חייב להיות קיים במודל ההמרה לאסימונים.	מחרוזת
`stop_tokens`	הדגמה של אסימוני עצירה ספציפיים. אסימוני העצירה חייבים להיות קיימים במודל ההמרה לאסימונים.	רשימה[STRING]
`output_filename`	שם קובץ חבילת משימות הפלט.	PATH

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

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

התמיכה של LoRA ב-LLM Inference API פועלת במודלים מסוג Gemma-2B ו-Pi-2 בקצה העורפי של ה-GPU, עם משקלי LoRA שרלוונטיים לשכבות תשומת לב בלבד. ההטמעה הראשונית הזו משמשת כ-API ניסיוני לפיתוחים עתידיים, עם תוכניות לתמוך במודלים נוספים ובסוגים שונים של שכבות בעדכונים הקרובים.

הכנת מודלים של LoRA

פועלים לפי ההוראות ב-HugingFace כדי לאמן מודל LoRA שעבר כוונון עדין במערך נתונים משלכם עם סוגי מודלים נתמכים, Gemma-2B או Phi-2. הדגמים Gemma-2B ו-Pi-2 זמינים ב-HugingFace בפורמט 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, שזמינים ב-HugingFace. לדוגמה: 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

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