TensorFlow Lite in der Java API der Google Play-Dienste

Auf TensorFlow Lite in Google Play-Diensten kann neben der nativen API auch über Java APIs zugegriffen werden. Insbesondere ist TensorFlow Lite in Google Play-Diensten über die TensorFlow Lite Interpreter API verfügbar.

Interpreter APIs verwenden

Die TensorFlow Lite Interpreter API, die von der TensorFlow-Laufzeit bereitgestellt wird, bietet eine universelle Schnittstelle zum Erstellen und Ausführen von ML-Modellen. Führen Sie die folgenden Schritte aus, um Inferenzen mit der Interpreter API und der Laufzeit von TensorFlow Lite in den Google Play-Diensten auszuführen.

1. Projektabhängigkeiten hinzufügen

Fügen Sie dem Code Ihres App-Projekts die folgenden Abhängigkeiten hinzu, um auf die Play Services API für TensorFlow Lite zuzugreifen:

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. Initialisierung von TensorFlow Lite hinzufügen

Initialisieren Sie die TensorFlow Lite-Komponente der Google Play Services API, bevor Sie die TensorFlow Lite APIs verwenden:

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

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

3. Interpreter erstellen und Laufzeitoption festlegen

Erstellen Sie mit InterpreterApi.create() einen Interpreter und konfigurieren Sie ihn für die Verwendung der Laufzeit der Google Play-Dienste. Dazu rufen Sie InterpreterApi.Options.setRuntime() auf, wie im folgenden Beispielcode gezeigt:

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

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

Sie sollten die obige Implementierung verwenden, da dadurch der Thread der Android-Benutzeroberfläche nicht blockiert wird. Wenn Sie die Threadausführung genauer verwalten müssen, können Sie einen Tasks.await()-Aufruf zum Erstellen von Interpretern hinzufügen:

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

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

4. Inferenzen ausführen

Rufen Sie mithilfe des von Ihnen erstellten interpreter-Objekts die run()-Methode auf, um eine Inferenz zu generieren.

interpreter.run(inputBuffer, outputBuffer)

interpreter.run(inputBuffer, outputBuffer);

Hardwarebeschleunigung

TensorFlow Lite ermöglicht Ihnen, die Leistung Ihres Modells mithilfe spezieller Hardwareprozessoren wie Grafikprozessoren (GPUs) zu beschleunigen. Sie können diese speziellen Prozessoren mithilfe von Hardwaretreibern, den sogenannten Delegierten, nutzen.

Der GPU-Delegate wird über Google Play-Dienste bereitgestellt und dynamisch geladen, genau wie die Play-Dienste-Versionen der Interpreter API.

Gerätekompatibilität wird geprüft

Nicht alle Geräte unterstützen die GPU-Hardwarebeschleunigung mit TFLite. Verwenden Sie die Methode TfLiteGpu.isGpuDelegateAvailable, um zu prüfen, ob ein Gerät mit dem GPU-Delegaten kompatibel ist, um Fehler und potenzielle Abstürze zu vermeiden.

Mit dieser Methode können Sie prüfen, ob ein Gerät mit GPU kompatibel ist, und die CPU als Fallback verwenden, wenn GPU nicht unterstützt wird.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Sobald Sie eine Variable wie useGpuTask haben, können Sie damit bestimmen, ob Geräte den GPU-Delegaten verwenden.

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

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 mit Interpreter APIs

So verwenden Sie den GPU-Delegaten mit den Interpreter APIs:

1. Aktualisieren Sie die Projektabhängigkeiten, um den GPU-Delegaten der Play-Dienste zu verwenden:

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

2. Aktivieren Sie die GPU-Delegate-Option in der TFlite-Initialisierung:

   Kotlin

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

   Java

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

3. Aktivieren Sie den GPU-Delegaten in den Interpreteroptionen: Legen Sie die Delegat-Factory auf GpuDelegateFactory fest, indem Sie addDelegateFactory() withinInterpreterApi.Options()` aufrufen:

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

Von eigenständigem TensorFlow Lite migrieren

Wenn Sie Ihre App vom eigenständigen TensorFlow Lite zur Play Services API migrieren möchten, lesen Sie die folgenden zusätzlichen Hinweise zum Aktualisieren des App-Projektcodes:

1. Prüfen Sie den Abschnitt Einschränkungen auf dieser Seite, um sicherzustellen, dass Ihr Anwendungsfall unterstützt wird.
2. Führen Sie vor dem Aktualisieren des Codes Leistungs- und Genauigkeitsprüfungen für Ihre Modelle durch, insbesondere wenn Sie Versionen von TensorFlow Lite vor Version 2.1 verwenden. So haben Sie eine Referenz, die Sie mit der neuen Implementierung vergleichen können.
3. Wenn Sie den gesamten Code zur Verwendung der Play Services API für TensorFlow Lite migriert haben, sollten Sie die vorhandenen Abhängigkeiten der Laufzeitbibliothek von TensorFlow Lite (Einträge mit org.tensorflow:tensorflow-lite:*) aus der Datei build.gradle entfernen, um die App-Größe zu reduzieren.
4. Ermitteln Sie alle Vorkommen der new Interpreter-Objekterstellung in Ihrem Code und ändern Sie jedes Element so, dass es den Aufruf „InterpreterApi.create()“ verwendet. Die neue Version von TfLite.initial ist asynchron, d. h., in den meisten Fällen ist es kein Drop-in-Ersatz: Sie müssen einen Listener für den Abschluss des Aufrufs registrieren. Sehen Sie sich das Code-Snippet in Schritt 3 an.
5. Fügen Sie allen Quelldateien mithilfe der Klassen org.tensorflow.lite.Interpreter oder org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi; und import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; hinzu.
6. Wenn einer der resultierenden Aufrufe von InterpreterApi.create() nur ein einzelnes Argument hat, hängen Sie new InterpreterApi.Options() an die Argumentliste an.
7. Hängen Sie .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) an das letzte Argument von Aufrufen von InterpreterApi.create() an.
8. Ersetzen Sie alle anderen Vorkommen der Klasse org.tensorflow.lite.Interpreter durch org.tensorflow.lite.InterpreterApi.

Wenn Sie das eigenständige TensorFlow Lite und die Play Services API parallel verwenden möchten, müssen Sie TensorFlow Lite 2.9 (oder höher) verwenden. TensorFlow Lite 2.8 und frühere Versionen sind nicht mit der Version der Play Services API kompatibel.