TensorFlow חוזר ל-Google I/O ב-14 במאי! הירשם עכשיו

דף זה תורגם על ידי Cloud Translation API.

TensorFlow Lite בשירותי Google Play Java API

ניתן לגשת ל- TensorFlow Lite בשירותי Google Play גם באמצעות ממשקי API של Java, בנוסף ל-Native API. במיוחד, TensorFlow Lite בשירותי Google Play זמין דרך TensorFlow Lite Task API ו- TensorFlow Lite Interpreter API . ספריית המשימות מספקת ממשקי מודל אופטימליים מחוץ לקופסה למשימות נפוצות של למידת מכונה באמצעות נתוני חזותיים, אודיו וטקסט. ה- API של TensorFlow Lite Interpreter, המסופק על ידי זמן הריצה של TensorFlow, מספק ממשק למטרות כלליות יותר לבנייה והרצה של מודלים של ML.

הסעיפים הבאים מספקים הוראות כיצד להשתמש בממשקי ה-API של Interpreter ו-Task Library עם TensorFlow Lite בשירותי Google Play. אמנם אפליקציה יכולה להשתמש גם בממשקי API של Interpreter וגם בממשקי API של ספריית משימות, אבל רוב האפליקציות צריכות להשתמש רק בקבוצה אחת של ממשקי API.

שימוש בממשקי ה-API של ספריית המשימות

ה-TensorFlow Lite Task API עוטף את Interpreter API ומספק ממשק תכנות ברמה גבוהה למשימות למידת מכונה נפוצות המשתמשות בנתוני חזותיים, אודיו וטקסט. עליך להשתמש ב-Task API אם היישום שלך דורש אחת מהמשימות הנתמכות .

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

התלות בפרויקט שלך תלויה במקרה השימוש שלך למידת מכונה. ממשקי ה-API של המשימות מכילים את הספריות הבאות:

ספריית חזון: org.tensorflow:tensorflow-lite-task-vision-play-services
ספריית אודיו: org.tensorflow:tensorflow-lite-task-audio-play-services
ספריית טקסט: org.tensorflow:tensorflow-lite-task-text-play-services

הוסף אחת מהתלות לקוד פרויקט האפליקציה שלך כדי לגשת ל-Play Services API עבור TensorFlow Lite. לדוגמה, השתמש בדברים הבאים כדי ליישם משימת חזון:

dependencies {
...
    implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
...
}

2. הוסף אתחול של TensorFlow Lite

אתחל את רכיב TensorFlow Lite של ה-API של שירותי Google Play לפני השימוש בממשקי ה-API של TensorFlow Lite. הדוגמה הבאה מאתחלת את ספריית החזון:

קוטלין

init {
  TfLiteVision.initialize(context)
}

3. הפעל מסקנות

לאחר אתחול הרכיב TensorFlow Lite, קרא לשיטת detect() כדי ליצור מסקנות. הקוד המדויק בשיטת detect() משתנה בהתאם לספרייה ולמקרה השימוש. להלן מקרה שימוש פשוט לזיהוי אובייקטים עם ספריית TfLiteVision :

קוטלין

fun detect(...) {
  if (!TfLiteVision.isInitialized()) {
    Log.e(TAG, "detect: TfLiteVision is not initialized yet")
    return
  }

  if (objectDetector == null) {
    setupObjectDetector()
  }

  ...

}

בהתאם לפורמט הנתונים, ייתכן שתצטרך גם לעבד מראש ולהמיר את הנתונים שלך בשיטת detect() לפני יצירת מסקנות. לדוגמה, נתוני תמונה עבור גלאי אובייקטים דורשים את הדברים הבאים:

val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
val results = objectDetector?.detect(tensorImage)

שימוש בממשקי ה-API של Interpreter

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

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

הוסף את התלות הבאות לקוד פרויקט האפליקציה שלך כדי לגשת ל-Play Services API עבור TensorFlow Lite:

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

2. הוסף אתחול של TensorFlow Lite

אתחל את רכיב TensorFlow Lite של ה-API של שירותי Google Play לפני השימוש בממשקי ה-API של TensorFlow Lite:

קוטלין

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

Java

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

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

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

קוטלין

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()));
  });

עליך להשתמש ביישום שלמעלה מכיוון שהוא נמנע מחסימת שרשור ממשק המשתמש של אנדרואיד. אם אתה צריך לנהל את ביצוע השרשור מקרוב יותר, אתה יכול להוסיף קריאה Tasks.await() ליצירת המתורגמן:

קוטלין

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

Java

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

4. הפעל מסקנות

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

קוטלין

interpreter.run(inputBuffer, outputBuffer)

Java

interpreter.run(inputBuffer, outputBuffer);

האצת חומרה

TensorFlow Lite מאפשר לך להאיץ את הביצועים של הדגם שלך באמצעות מעבדי חומרה מיוחדים, כגון יחידות עיבוד גרפיות (GPUs). אתה יכול לנצל את המעבדים המיוחדים הללו באמצעות מנהלי התקנים של חומרה הנקראים Delegates . אתה יכול להשתמש בנציגי האצת החומרה הבאים עם TensorFlow Lite בשירותי Google Play:

נציג GPU (מומלץ) - נציג זה מסופק דרך שירותי Google Play ונטען באופן דינמי, בדיוק כמו גרסאות שירותי Play של ה-Task API ו-Interpreter API.
נציג NNAPI - נציג זה זמין כתלות ספרייה כלולה בפרויקט הפיתוח של Android שלך, ומצורף לאפליקציה שלך.

למידע נוסף על האצת חומרה עם TensorFlow Lite, עיין בדף TensorFlow Lite Delegates .

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

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

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

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

ברגע שיש לך משתנה כמו useGpuTask , אתה יכול להשתמש בו כדי לקבוע אם מכשירים משתמשים ב-GPU Delegate. הדוגמאות הבאות מראות כיצד ניתן לעשות זאת הן עם ספריית המשימות והן עם ממשקי ה-API של המתורגמן.

עם ה-Task Api

קוטלין

lateinit val optionsTask = useGpuTask.continueWith { task ->
  val baseOptionsBuilder = BaseOptions.builder()
  if (task.result) {
    baseOptionsBuilder.useGpu()
  }
 ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
}

Java

Task<ObjectDetectorOptions> optionsTask = useGpuTask.continueWith({ task ->
  BaseOptions baseOptionsBuilder = BaseOptions.builder();
  if (task.getResult()) {
    baseOptionsBuilder.useGpu();
  }
  return ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
});

עם אפי המתורגמן

קוטלין

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 של המשימה:

עדכן את תלות הפרויקט כדי להשתמש בנציג ה-GPU משירותי Play:
```
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
```

אתחל את נציג ה-GPU עם setEnableGpuDelegateSupport . לדוגמה, אתה יכול לאתחל את נציג ה-GPU עבור TfLiteVision עם הפעולות הבאות:

קוטלין

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

Java

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

הפעל את אפשרות הנציג של GPU עם BaseOptions :

קוטלין

    val baseOptions = BaseOptions.builder().useGpu().build()

Java

    BaseOptions baseOptions = BaseOptions.builder().useGpu().build();

הגדר את האפשרויות באמצעות .setBaseOptions . לדוגמה, אתה יכול להגדיר GPU ב- ObjectDetector עם הדברים הבאים:

קוטלין

    val options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build()

Java

    ObjectDetectorOptions options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build();

GPU עם ממשקי API של מתורגמן

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

עדכן את תלות הפרויקט כדי להשתמש בנציג ה-GPU משירותי Play:
```
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
```

הפעל את אפשרות הנציג של GPU באתחול TFlite:

קוטלין

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

Java

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

אפשר נציג GPU באפשרויות המתורגמן: הגדר את מפעל הנציג ל-GpuDelegateFactory על ידי קריאה ל- addDelegateFactory() within InterpreterApi.Options()`:

קוטלין

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

Java

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

מעבר מ-TensorFlow Lite העומד בפני עצמו

אם אתה מתכנן להעביר את האפליקציה שלך מ-TensorFlow Lite העצמאי ל-Play Services API, עיין בהנחיה הנוספת הבאה לעדכון קוד פרויקט האפליקציה שלך:

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

אם ברצונך להשתמש ב-TensorFlow Lite העצמאי וב-Play Services API זה לצד זה, עליך להשתמש TensorFlow Lite 2.9 (או מאוחר יותר). TensorFlow Lite 2.8 וגרסאות קודמות אינן תואמות לגרסת ה-API של שירותי Play.