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

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

אפשר לראות את המשימה הזו בפעולה ב-MediaPipe Studio . מידע נוסף על היכולות, המודלים ואפשרויות ההגדרה במשימה הזאת, ראו סקירה כללית.

קוד לדוגמה

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

להורדת הקוד

בהוראות הבאות מוסבר איך ליצור עותק מקומי של הדוגמה באמצעות כלי שורת הפקודה git.

כדי להוריד את הקוד לדוגמה:

1. משכפלים את מאגר ה-Git באמצעות הפקודה הבאה:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. לחלופין, להגדיר את מכונת ה-Git שלך לשימוש בקופה עם היעדר תשלום, כדי רק הקבצים של האפליקציה לדוגמה של LLM Inference API:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/llm_inference/ios/
   

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

הגדרה

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

יחסי תלות

LLM Inference API משתמש בספרייה MediaPipeTasksGenai, שצריכה להיות מותקנת באמצעות CocoaPods. הספרייה תואמת גם לאפליקציות Swift ו-Objective-C ולא נדרשת הגדרה נוספת ספציפית לשפה.

הוראות להתקנת CocoaPods ב-macOS מפורטות במאמר CocoaPods במדריך ההתקנה. לקבלת הוראות ליצירת Podfile עם ה-pods שדרושים באפליקציה, קראו את המאמר שימוש CocoaPods.

מוסיפים את הרצף MediaPipeTasksGenai ב-Podfile באמצעות הקוד הבא:

target 'MyLlmInferenceApp' do
  use_frameworks!
  pod 'MediaPipeTasksGenAI'
  pod 'MediaPipeTasksGenAIC'
end

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

דגם

למשימה של MediaPipe LLM Inference API נדרש מודל מאומן שתואם במשימה הזו. לקבלת מידע נוסף על מודלים זמינים מאומנים של ב-LLM Inference API אפשר לעיין בסקירה הכללית על המשימה בקטע 'מודלים'.

הורדת מודל

מורידים מודל ומוסיפים אותו לספריית הפרויקט באמצעות Xcode. עבור לקבלת הוראות להוספת קבצים לפרויקט Xcode, קראו את המאמר ניהול קבצים ותיקיות ב-Xcode project.

הורדת Gemma 2B

כשיוצרים אפליקציות ל-iOS, כדאי להשתמש באחת מהווריאציות הבאות:

• gemma-2b-it-cpu-int4: מודל 4 ביט של Gemma עם תאימות למעבד (CPU).
• gemma-2b-it-gpu-int4: מודל 4 ביט של Gemma עם תאימות ל-GPU.
• מודלים ממופים של AI Edge Torch שתואמים לדרישות הזיכרון של iOS.

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

יצירת המשימה

כדי ליצור את המשימה של LLM Inference API, אפשר להפעיל אחד מהמאתחלים שלו. המאתחל LlmInference(options:) מגדיר ערכים לאפשרויות ההגדרה.

אם אתם לא צריכים ממשק API להסקת מסקנות (LLM) שאותחל עם הגדרות אישיות אפשר להשתמש במאתחל של LlmInference(modelPath:) כדי ליצור ממשק API להסקת מסקנות (LLM) עם אפשרויות ברירת המחדל. מידע נוסף על הגדרה אפשרויות נוספות, ראו סקירה כללית של ההגדרות.

הקוד הבא מדגים איך יוצרים ומגדירים את המשימה הזו.

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")

let options = LlmInferenceOptions()
options.baseOptions.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101

let LlmInference = try LlmInference(options: options)

אפשרויות תצורה

המשימה הזו כוללת את אפשרויות ההגדרה הבאות לאפליקציות ל-iOS:

הכנת נתונים

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

כל העיבוד מראש מטופל בתוך הפונקציה generateResponse(inputText:). אין צורך בעיבוד נוסף של טקסט הקלט מראש.

let inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday."

הרצת המשימה

כדי להריץ את LLM Inference API, צריך להשתמש ב-method generateResponse(inputText:). LLM Inference API מחזיר את הקטגוריות האפשריות של טקסט הקלט.

let result = try LlmInference.generateResponse(inputText: inputPrompt)

כדי לשדר את התשובה בסטרימינג, משתמשים בשיטה generateResponseAsync(inputText:).

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

do {
  for try await partialResult in resultStream {
    print("\(partialResult)")
  }
  print("Done")
}
catch {
  print("Response error: '\(error)")
}

טיפול בתוצאות והצגתן

LLM Inference API מחזיר LlmInferenceResult, שכולל את טקסט התשובה.

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

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

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")
let loraPath= Bundle.main.path(forResource: "lora_model",
                                      ofType: "bin")
let options = LlmInferenceOptions()
options.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101
options.loraPath = loraPath

let LlmInference = try LlmInference(options: options)

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