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

Auf LiteRT in Google Play-Diensten kann zusätzlich zur Native API auch über Java APIs zugegriffen werden, die aus 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 unter Verwendung von TensorFlow Lite in der Google Play-Dienstlaufzeit 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 vor der Verwendung der LiteRT APIs:

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 so, dass er die Google Play-Dienste-Laufzeit verwendet. Rufen Sie dazu 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 oben beschriebene Implementierung verwenden, da dadurch der Android-Benutzeroberflächen-Thread nicht blockiert wird. Wenn Sie die Threadausführung genauer verwalten müssen, können Sie einen Tasks.await()-Aufruf zum Erstellen des Interpreters 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 mit dem von Ihnen 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 GPUs (Graphics Processing Units) beschleunigen. Sie können diese speziellen Prozessoren mithilfe von Hardwaretreibern namens Delegierte nutzen.

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

Gerätekompatibilität prüfen

Nicht alle Geräte unterstützen die GPU-Hardwarebeschleunigung mit TFLite. Prüfen Sie mit der Methode TfLiteGpu.isGpuDelegateAvailable, 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 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 feststellen, ob Geräte den GPU-Delegierten 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-Delegierten mit den Interpreter APIs:

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

   implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.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. GPU-Delegierten in den Interpreteroptionen aktivieren: Legen Sie die Delegating 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 der eigenständigen LiteRT-Version migrieren

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

1. Sehen Sie im Abschnitt Einschränkungen auf dieser Seite nach, ob Ihr Anwendungsfall unterstützt wird.
2. Bevor Sie Ihren Code aktualisieren, empfehlen wir Ihnen, Leistungs- und Genauigkeitstests für Ihre Modelle durchzuführen. Dies gilt insbesondere, wenn Sie LiteRT-Versionen (TF Lite) vor Version 2.1 verwenden, damit Sie einen Vergleichswert für die neue Implementierung haben.
3. Wenn Sie Ihren gesamten Code zur Verwendung der Play-Dienste API für LiteRT migriert haben, sollten Sie die vorhandenen Abhängigkeiten der LiteRT-Laufzeitbibliothek (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, was bedeutet, dass sie in den meisten Fällen nicht einfach ersetzt werden kann: Sie müssen einen Listener für den Abschluss des Aufrufs registrieren. Siehe Code-Snippet in Schritt 3.
5. Fügen Sie allen Quelldateien 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 hinzu.
6. Wenn einer der resultierenden Aufrufe von InterpreterApi.create() nur ein einziges Argument hat, fügen Sie der Argumentliste new InterpreterApi.Options() hinzu.
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 das 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 niedriger sind nicht mit der Play-Dienste API-Version kompatibel.