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

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

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

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

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

כדי לגשת ל-Play Services API עבור 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 ב-API של Google Play Services לפני השימוש בממשקי ה-API של LiteRT:

Kotlin

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

Java

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

3. יצירת תרגום שיחה פעילה והגדרת אפשרות של סביבת זמן ריצה

אתם יכולים ליצור תרגום באמצעות 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). אפשר לנצל את היתרונות של המעבדים המיוחדים האלה באמצעות מנהלי חומרה שנקראים נציגים.

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

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

לא כל המכשירים תומכים בהאצת חומרה של 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 עם ממשקי API של מתורגמים

כדי להשתמש במתווך ה-GPU עם ממשקי ה-API של המתורגם:

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

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

  2. הפעלת האפשרות להענקת גישה ל-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 היא אסינכררונית, כלומר ברוב המקרים אי אפשר להחליף אותה בקוד ישירות: צריך לרשום מאזין לזמן שבו הקריאה תושלם. מעיינים בקטע הקוד בקוד של שלב 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 עצמאי וב-Play Services API במקביל, עליכם להשתמש ב-LiteRT (TF Lite) בגרסה 2.9 ואילך. גרסה 2.8 של LiteRT‏ (TF Lite) וגרסאות ישנות יותר לא תואמות לגרסה של Play Services API.