ברוכים הבאים לסקירה הכללית של LiteRT

‫LiteRT הוא מסגרת של Google להטמעה של ML ו-GenAI בביצועים גבוהים במכשיר בפלטפורמות קצה, באמצעות המרה, זמן ריצה ואופטימיזציה יעילים.

‫LiteRT 2.x מכיל את ה-API העדכני ביותר של זמן הריצה, CompiledModel API, שמשפר את Interpreter API (שנקרא גם TensorFlow Lite APIs), במיוחד באמצעות האצת חומרה וביצועים כלליים עבור אפליקציות של ML ו-AI במכשיר. ממשק ה-API של CompiledModel הוא בגרסת בטא וזמין ב-Kotlin וב-C++.

תכונות עיקריות של LiteRT

מודלים נתמכים

‫LiteRT תומך בהמרה יעילה מ-Pytorch,‏ TensorFlow ו-JAX לפורמט ‎ .tflite או ‎ .litertlm.

מייעלים את הפיתוח באמצעות LiteRT

בחירה אוטומטית של מאיץ לעומת יצירה מפורשת של נציג. זמן ריצה פשוט של NPU והפצת מודלים. טיפול יעיל במאגר I/O וביצוע אסינכרוני לביצועים מעולים.

ביצועי ה-GPU הטובים ביותר

התכונה מבוססת על ML Drift, ועכשיו היא תומכת גם במודלים של למידת מכונה (ML) וגם במודלים של AI גנרטיבי בממשקי API של מעבדי GPU.

האצת NPU מאוחדת

להאיץ את המודל באמצעות גישה פשוטה יותר ל-NPU מספקי ערכות שבבים מובילים.

תמיכה פשוטה במודלים של שפה גדולה (LLM) באמצעות LiteRT

אפשר להשתמש ב-LiteRT-LM שמבוסס על LiteRT. ‫LiteRT-LM תומך במודלי השפה הגדולים העדכניים ביותר ובתכונות שימושיות כמו ריבוי אופנים, פענוח מוגבל וכו'.

תהליך עבודה של פיתוח

‫LiteRT מריץ מסקנות באופן מלא במכשיר ב-Android,‏ iOS, באינטרנט, ב-IoT ובמחשב שולחני או נייד. לא משנה באיזה מכשיר משתמשים, זהו תהליך העבודה הנפוץ ביותר, עם קישורים להוראות נוספות.

לזהות את הפתרון המתאים ביותר לאתגר של למידת המכונה

‫LiteRT מציע למשתמשים רמה גבוהה של גמישות ואפשרויות התאמה אישית כשמדובר בפתרון בעיות של למידת מכונה, ולכן הוא מתאים למשתמשים שזקוקים למודל ספציפי או להטמעה מיוחדת. משתמשים שמחפשים פתרונות מוכנים לשימוש עשויים להעדיף את MediaPipe Tasks, שמספק פתרונות מוכנים למשימות נפוצות של למידת מכונה כמו זיהוי אובייקטים, סיווג טקסט והסקת מסקנות של LLM.

קבלת המודל והכנתו

מודל LiteRT מיוצג בפורמט נייד ויעיל שנקרא FlatBuffers, עם סיומת הקובץ .tflite.

אפשר לקבל מודל LiteRT בדרכים הבאות:

• קבלת מודל שאומן מראש: למשימות פופולריות של למידת מכונה כמו פילוח תמונות, זיהוי אובייקטים וכו'.

  הגישה הכי פשוטה היא להשתמש במודל LiteRT שכבר נמצא בפורמט .tflite. המודלים האלה לא דורשים שלבי המרה נוספים.

  סוג המודל	מקור של מודל שעבר אימון מראש
  למידת מכונה קלאסית (פורמט .tflite)	אפשר להיכנס ל-Kaggle או ל-HuggingFace לדוגמה, מודלים של חלוקת תמונות למקטעים ואפליקציה לדוגמה
  ‫AI גנרטיבי (.litertlm פורמט)	דף LiteRT Hugging Face לדוגמה: Gemma Family

• ממירים את מודל PyTorch,‏ TensorFlow או JAX שבחרתם למודל LiteRT אם בחרתם לא להשתמש במודל שאומן מראש. [PRO USER]

  Model Framework	מודלים לדוגמה	כלי ההמרה
  Pytorch	‫Hugging Face Torchvision	קישור
  TensorFlow	מודלים של Kaggle Hugging Face	קישור
  Jax	Hugging Face	קישור

• יצירת מודל שפה גדול (LLM) לאופטימיזציה נוספת באמצעות Generative API [משתמשי PRO]

  ספריית Generative API מספקת אבני בניין מובְנות של PyTorch ליצירת מודלים של Transformer כמו Gemma,‏ TinyLlama ואחרים באמצעות הפשטות שמתאימות לניידים, שדרכן אנחנו יכולים להבטיח המרה וביצוע יעיל בזמן הריצה בנייד, LiteRT. לעיון במסמכי ה-API הגנרטיבי

קוונטיזציה [משתמשי PRO]

‫AI Edge Quantizer למפתחים מתקדמים הוא כלי לכימות מודלים של LiteRT שהומרו. היא נועדה לעזור למשתמשים מתקדמים להשיג ביצועים אופטימליים במודלים שדורשים משאבים רבים (למשל, מודלים של AI גנרטיבי).

למידע על מודלים של למידת מכונה ומודלים של AI גנרטיבי, אפשר לעיין במאמרי העזרה בנושא Ai-Edge-Quantization.

דרישות מקדימות

• ‫Python 3.10-3.12
• קובץ מודל .tflite
• פרטים נוספים זמינים בסעיף של הפלטפורמה הרלוונטית

שילוב המודל באפליקציה בפלטפורמות קצה

אפשר להטמיע את מודלי LiteRT כדי להריץ מסקנות באופן מלא במכשיר ב-Android,‏ iOS, באינטרנט, ב-IoT ובמחשבים. ‫LiteRT כולל ממשקי API ל-Python,‏ Java ו-Kotlin ל-Android,‏ Swift ל-iOS ו-C++‎ למכשירי מיקרו.

כדי להטמיע מודל LiteRT בפלטפורמה המועדפת עליכם, תוכלו להיעזר במדריכים הבאים:

*בקרוב

דוגמה לקוד ב-Kotlin

// Load model and initialize runtime
val compiledModel = CompiledModel.create("/path/to/mymodel.tflite", CompiledModel.Options(Accelerator.CPU))

// Prepare I/O buffers and fill in the data
val inputBuffers = compiledModel.createInputBuffers()
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

val outputBuffers = compiledModel.createOutputBuffers()

// Execute model
compiledModel.run(inputBuffers, outputBuffers)

// Access model output
val output = outputBuffers.get(0).readFloat()

inputBuffers.forEach { it.close() }
outputBuffers.forEach { it.close() }
compiledModel.close()

דוגמה לקוד C++‎

LITERT_ASSIGN_OR_RETURN(auto env, GetEnvironment());
LITERT_ASSIGN_OR_RETURN(auto options, GetOptions());
LITERT_ASSIGN_OR_RETURN(
      auto compiled_model,
      CompiledModel::Create(env, "/path/to/mymodel.tflite", options));
LITERT_ASSIGN_OR_RETURN(auto input_buffers,compiled_model.CreateInputBuffers(signature_index));
LITERT_ASSIGN_OR_RETURN(auto output_buffers,compiled_model.CreateOutputBuffers(signature_index));
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

LITERT_ABORT_IF_ERROR(compiled_model.Run(signature_index, input_buffers, output_buffers));

LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

בחירת קצה עורפי

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

הליבה של LiteRT v2.x היא אובייקט CompiledModel. כשמטעינים מודל, LiteRT משתמש בחומרה הזמינה של המערכת ובלוגיקה פנימית של עדיפות כדי לבחור את העורף האופטימלי בלי הגדרה ידנית. פרטים נוספים זמינים במאמר בנושא קצה עורפי.

מסמכים נוספים ותמיכה

אפליקציה לדוגמה של LiteRT v2.x ראו אפליקציה לדוגמה של LiteRT Image Segmentation

למשתמשים קיימים ב-TensorFlow Lite ראו מדריך להעברת נתונים

כיסוי תפעולי אופרטורים תואמים

מודלים נתמכים של LLM ‫LiteRT Hugging face ו-Gen API – דוגמאות

כלים דף הכלים של LiteRT – ביצועים, יצירת פרופילים, דיווח על שגיאות וכו'.