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

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

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

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

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

בחירה אוטומטית של מאיץ לעומת יצירה מפורשת של נציג. טיפול יעיל במאגרים של קלט/פלט וביצוע אסינכרוני לביצועים מעולים. מידע נוסף על הסקת מסקנות במכשיר

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

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

האצת NPU מאוחדת

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

תמיכה משופרת ב-LLM

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

תמיכה רחבה ב-framework של למידת מכונה

‫LiteRT תומך בהמרה יעילה מ-frameworks של PyTorch,‏ TensorFlow ו-JAX לפורמט .tflite או .litertlm. מידע נוסף על המרות לפי מודל

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

‫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 Edge Quantizer.

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

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

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

בקטעי הקוד הבאים מוצגת הטמעה בסיסית ב-Kotlin וב-C++.

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

// Preallocate input/output buffers
val inputBuffers = compiledModel.createInputBuffers()
val outputBuffers = compiledModel.createOutputBuffers()

// Fill the input buffer
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

// Invoke
compiledModel.run(inputBuffers, outputBuffers)

// Read the output
val output = outputBuffers.get(0).readFloat()

// Load model and initialize runtime
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));

// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers,compiled_model.CreateInputBuffers(signature_index));
LITERT_ASSIGN_OR_RETURN(auto output_buffers,compiled_model.CreateOutputBuffers(signature_index));

// Fill the input buffer
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

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

// Read the output
LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

בחירת שיפור המהירות באמצעות חומרה

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

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

• מאגר GitHub של LiteRT-Samples לדוגמאות נוספות של אפליקציות LiteRT.

• משתמשים קיימים ב-TensorFlow Lite יכולים לעיין במדריך להעברת נתונים.

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