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

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

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

לא כל המכשירים תומכים בהאצת חומרה של 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 של Google Translate

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

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

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

  2. הפעלת האפשרות להענקת גישה ל-GPU באתחול TFlite:

    Kotlin

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

    Java

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

  3. הפעלת האפשרות להענקת גישה ל-GPU באפשרויות המתורגמן: הגדרת היצרן להענקת גישה Gpu למודעת מכוסת קריאה ל-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 (ואילך). LiteRT 2.8 וגרסאות קודמות לא תואמות לגרסת ה-API של Play Services.