LiteRT ב-Java (ו-Kotlin) API של Google Play Services

אפשר לגשת ל-LiteRT ב-Google Play Services גם באמצעות Java APIs, שאפשר להשתמש בהם מקוד Java או Kotlin, בנוסף ל-Native API. באופן ספציפי, LiteRT בשירותי Google Play זמין דרך LiteRT Interpreter API.

שימוש בממשקי ה-API של תרגום השיחה הפעילה

‫LiteRT Interpreter API, שמסופק על ידי זמן הריצה של TensorFlow, מספק ממשק למטרות כלליות לבנייה ולהרצה של מודלים של למידת מכונה. כדי להריץ מסקנות באמצעות Interpreter API באמצעות TensorFlow Lite בסביבת זמן הריצה של Google Play Services, פועלים לפי השלבים הבאים.

1. הוספת יחסי תלות של הפרויקט

כדי לגשת ל-API של Play Services עבור LiteRT, מוסיפים את התלויות הבאות לקוד של פרויקט האפליקציה:

dependencies {
...
    // LiteRT dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.1.0'
    // Optional: include LiteRT Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.1.0'
...
}

2. הוספת אתחול של LiteRT

מאתחלים את רכיב LiteRT של Google Play services API לפני שמשתמשים ב-LiteRT APIs:

Kotlin

val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }

Java

Task<Void> initializeTask = TfLite.initialize(context);

3. יצירת Interpreter והגדרת אפשרות זמן ריצה

יוצרים מפענח באמצעות InterpreterApi.create() ומגדירים אותו לשימוש בזמן הריצה של Google Play Services על ידי קריאה ל-InterpreterApi.Options.setRuntime(), כמו שמוצג בקוד לדוגמה הבא:

Kotlin

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private lateinit var interpreter: InterpreterApi
...
initializeTask.addOnSuccessListener {
  val interpreterOption =
    InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  interpreter = InterpreterApi.create(
    modelBuffer,
    interpreterOption
  )}
  .addOnFailureListener { e ->
    Log.e("Interpreter", "Cannot initialize interpreter", e)
  }

Java

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private InterpreterApi interpreter;
...
initializeTask.addOnSuccessListener(a -> {
    interpreter = InterpreterApi.create(modelBuffer,
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY));
  })
  .addOnFailureListener(e -> {
    Log.e("Interpreter", String.format("Cannot initialize interpreter: %s",
          e.getMessage()));
  });

מומלץ להשתמש בהטמעה שלמעלה כי היא מונעת חסימה של השרשור בממשק המשתמש של Android. אם אתם צריכים לנהל את הביצוע של השרשור בצורה מדויקת יותר, אתם יכולים להוסיף קריאה ל-Tasks.await() ליצירת המפענח:

Kotlin

import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}

Java

@BackgroundThread
InterpreterApi initializeInterpreter() {
    Tasks.await(initializeTask);
    return InterpreterApi.create(...);
}

4. הרצת מסקנות

באמצעות אובייקט interpreter שיצרתם, קוראים ל-method‏ run() כדי ליצור מסקנה.

Kotlin

interpreter.run(inputBuffer, outputBuffer)

Java

interpreter.run(inputBuffer, outputBuffer);

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

‫LiteRT מאפשר להאיץ את הביצועים של המודל באמצעות מעבדי חומרה ייעודיים, כמו מעבדים גרפיים (GPU). אפשר להשתמש במעבדים המיוחדים האלה באמצעות מנהלי התקנים של חומרה שנקראים delegates.

ה-GPU delegate מסופק דרך Google Play Services ונטען באופן דינמי, בדיוק כמו גרסאות Play Services של Interpreter API.

בדיקת התאימות של המכשיר

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

אפשר להשתמש בשיטה הזו כדי לוודא שמכשיר תואם ל-GPU, ולהשתמש ב-CPU כגיבוי למקרים שבהם אין תמיכה ב-GPU.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

אחרי שיש לכם משתנה כמו useGpuTask, אתם יכולים להשתמש בו כדי לקבוע אם המכשירים משתמשים בנציג GPU.

Kotlin

val interpreterTask = useGpuTask.continueWith { task ->
  val interpreterOptions = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  if (task.result) {
      interpreterOptions.addDelegateFactory(GpuDelegateFactory())
  }
  InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions)
}

Java

Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task ->
  InterpreterApi.Options options =
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY);
  if (task.getResult()) {
     options.addDelegateFactory(new GpuDelegateFactory());
  }
  return options;
});

GPU with Interpreter APIs

כדי להשתמש ב-GPU delegate עם Interpreter APIs:

  1. מעדכנים את יחסי התלות של הפרויקט כדי להשתמש ב-GPU delegate מ-Play Services:

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'

  2. מפעילים את האפשרות GPU delegate (הקצאת GPU) באתחול של TFlite:

    Kotlin

    TfLite.initialize(context,
  TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true)
    .build())

    Java

    TfLite.initialize(context,
  TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true)
    .build());

  3. מפעילים את נציג ה-GPU באפשרויות של המפענח: מגדירים את מפעל הנציגים ל-GpuDelegateFactory על ידי קריאה ל-addDelegateFactory() withinInterpreterApi.Options()`:

    Kotlin

    val interpreterOption = InterpreterApi.Options()
  .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  .addDelegateFactory(GpuDelegateFactory())

    Java

    Options interpreterOption = InterpreterApi.Options()
  .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  .addDelegateFactory(new GpuDelegateFactory());

מעבר מ-LiteRT עצמאי

אם אתם מתכננים להעביר את האפליקציה מ-LiteRT עצמאי אל Play services API, כדאי לעיין בהנחיות הנוספות הבאות לעדכון קוד פרויקט האפליקציה:

  1. כדאי לעיין בקטע מגבלות כדי לוודא שהתרחיש לדוגמה שלכם נתמך.
  2. לפני שמעדכנים את הקוד, מומלץ לבצע בדיקות של הביצועים והדיוק של המודלים, במיוחד אם אתם משתמשים בגרסאות של LiteRT ‏(TF Lite) מגרסה 2.1 ומטה, כדי שיהיה לכם בסיס להשוואה מול ההטמעה החדשה.
  3. אם העברתם את כל הקוד לשימוש ב-Play services API ל-LiteRT, כדאי להסיר את התלות הקיימת בספריית זמן הריצה של LiteRT (רשומות עם org.tensorflow:tensorflow-lite:*) מהקובץ build.gradle כדי להקטין את גודל האפליקציה.
  4. מזהים את כל המקרים של יצירת אובייקט new Interpreter בקוד, ומשנים כל אחד מהם כך שישתמש בקריאה InterpreterApi.create(). השיטה החדשה TfLite.initialize היא אסינכרונית, כלומר ברוב המקרים היא לא תחליף מוכן לשימוש: צריך לרשום listener כדי לדעת מתי הקריאה מסתיימת. מעיינים בקטע הקוד בשלב 3.
  5. אפשר להוסיף את import org.tensorflow.lite.InterpreterApi; ו-import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; לכל קובץ מקור באמצעות המחלקות org.tensorflow.lite.Interpreter או org.tensorflow.lite.InterpreterApi.
  6. אם לאחת מהשיחות שמתקבלות אל InterpreterApi.create() יש רק ארגומנט אחד, מוסיפים את new InterpreterApi.Options() לרשימת הארגומנטים.
  7. מוסיפים .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) לארגומנט האחרון של כל הקריאות ל-InterpreterApi.create().
  8. מחליפים את כל המופעים האחרים של המחלקה org.tensorflow.lite.Interpreter ב-org.tensorflow.lite.InterpreterApi.

אם רוצים להשתמש ב-LiteRT עצמאי וב-API של שירותי Play זה לצד זה, צריך להשתמש ב-LiteRT (TF Lite) מגרסה 2.9 ואילך. גרסה 2.8 של LiteRT (TF Lite) וגרסאות קודמות לא תואמות לגרסת Play services API.