LiteRT in der Java- (und Kotlin-) API von Google Play-Diensten

Auf LiteRT in Google Play-Diensten kann neben der nativen API auch über Java-APIs zugegriffen werden, die in Java- oder Kotlin-Code verwendet werden können. Insbesondere ist LiteRT in Google Play-Diensten über die LiteRT Interpreter API verfügbar.

Interpreter APIs verwenden

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

1. Projektabhängigkeiten hinzufügen

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

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

Initialisieren Sie die LiteRT-Komponente der Google Play Services API bevor Sie die LiteRT 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 einen Interpreter mit InterpreterApi.create() und konfigurieren Sie ihn für die Verwendung der Google Play-Dienste-Laufzeit, indem Sie InterpreterApi.Options.setRuntime() aufrufen, 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 oben genannte Implementierung verwenden, da dadurch der Android-UI-Thread nicht blockiert wird. Wenn Sie die Ausführung von Threads genauer verwalten müssen, können Sie beim Erstellen des Interpreters einen Tasks.await()-Aufruf hinzufügen:

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

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

4. Schlussfolgerungen ziehen

Rufen Sie mit dem erstellten interpreter-Objekt die Methode run() auf, um eine Inferenz zu generieren.

interpreter.run(inputBuffer, outputBuffer)

interpreter.run(inputBuffer, outputBuffer);

Hardwarebeschleunigung

Mit LiteRT können Sie die Leistung Ihres Modells mithilfe spezieller Hardwareprozessoren wie Grafikprozessoren (GPUs) beschleunigen. Sie können diese Spezialprozessoren mithilfe von Hardwaretreibern nutzen, die als Delegates bezeichnet werden.

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

Gerätekompatibilität prüfen

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

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

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Sobald Sie eine Variable wie useGpuTask haben, können Sie damit festlegen, ob Geräte den GPU-Delegate 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-Delegate mit den Interpreter-APIs:

1. Aktualisieren Sie die Projektabhängigkeiten, um den GPU-Delegate aus den Play-Diensten zu verwenden:

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

2. Aktivieren Sie die Option „GPU-Delegate“ bei 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-Delegate in den Interpreter-Optionen: Legen Sie die Delegate-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 LiteRT migrieren

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

1. Lesen Sie den Abschnitt Einschränkungen, um sicherzugehen, dass Ihr Anwendungsfall unterstützt wird.
2. Bevor Sie Ihren Code aktualisieren, empfehlen wir Ihnen, Leistungs- und Genauigkeitsprüfungen für Ihre Modelle durchzuführen, insbesondere wenn Sie Versionen von LiteRT (TF Lite) vor Version 2.1 verwenden. So haben Sie eine Baseline, mit der Sie die neue Implementierung vergleichen können.
3. Wenn Sie Ihren gesamten Code migriert haben, um die Play Services API für LiteRT zu verwenden, sollten Sie die vorhandenen LiteRT-Laufzeitbibliotheksabhängigkeiten (Einträge mit org.tensorflow:tensorflow-lite:*) aus Ihrer build.gradle-Datei entfernen, um die App-Größe zu reduzieren.
4. Suchen Sie in Ihrem Code nach allen Vorkommen der new Interpreter-Objekterstellung und ändern Sie sie so, dass der InterpreterApi.create()-Aufruf verwendet wird. Die neue TfLite.initialize ist asynchron. Das bedeutet, dass sie in den meisten Fällen kein direkter Ersatz ist: Sie müssen einen Listener registrieren, der aufgerufen wird, wenn der Aufruf abgeschlossen ist. Weitere Informationen finden Sie im Code-Snippet in Schritt 3.
5. Fügen Sie import org.tensorflow.lite.InterpreterApi; und import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; mit den Klassen org.tensorflow.lite.Interpreter oder org.tensorflow.lite.InterpreterApi zu allen Quelldateien hinzu.
6. Wenn einer der resultierenden Aufrufe von InterpreterApi.create() nur ein 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 aller Aufrufe von InterpreterApi.create() an.
8. Ersetzen Sie alle anderen Vorkommen der Klasse org.tensorflow.lite.Interpreter durch org.tensorflow.lite.InterpreterApi.

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