LiteRT ב-Google Play Services ב-Java API

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

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

את LiteRT Translateer API, שסופק על ידי זמן הריצה של TensorFlow, מספקת ממשק לשימוש כללי לפיתוח ולהפעלה של מודלים של למידת מכונה. משתמשים ב כדי להריץ את ההֶקֵּשׁים בעזרת ה-Translate API באמצעות TensorFlow Lite בזמן הריצה של Google Play Services.

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

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

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

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 ולהשתמש במעבד (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 של Google Translate

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

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

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

  2. מפעילים את האפשרות GPU delegate בהפעלה הראשונית של TFlite:

    Kotlin

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

    Java

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

  3. הפעלת האפשרות להענקת גישה ל-GPU באפשרויות המתורגמן: הגדרת היצרן להענקת גישה ל: GpudelegatDefault מופעל באמצעות קריאה ל-addDelegateFactory() withinTranslateerApi.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 מגרסה 2.1, כך שיש לכם ערך בסיס להשוואה מול הגרסה החדשה יישום בפועל.
  3. אם העברתם את כל הקוד שלכם לשימוש ב-Play Services API ל-LiteRT, עליכם להסיר את יחסי התלות הקיימים בספריית זמן הריצה של LiteRT (הרשאות עם org.tensorflow:tensorflow-lite:*) מקובץ build.gradle כדי לצמצם את גודל האפליקציה.
  4. עליך לזהות את כל המופעים של יצירת אובייקט new Interpreter בקוד שלך, ולשנות כל אחד מהם כך שישתמש בקריאה interApi.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 נפרד וב-API Services של Play Services זה לצד זה, יש להשתמש ב-LiteRT 2.9 (ואילך). הגרסה 2.8 של LiteRT וגרסאות קודמות לא תואמות לגרסה של Play Services API.