Auf LiteRT in Google Play-Diensten kann auch über Java-APIs zugegriffen werden. zur Native API hinzufügen. Insbesondere LiteRT bei Google Play Dienste sind über den LiteRT-Interpreter verfügbar. API hinzu.
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. Verwenden Sie die Methode Führen Sie die folgenden Schritte aus, um Inferenzen mit der Interpreter API und der TensorFlow-Konfiguration auszuführen. Lite in der Laufzeit der Google Play-Dienste.
1. Projektabhängigkeiten hinzufügen
Füge deinem App-Projektcode die folgenden Abhängigkeiten hinzu, um auf den Play Store zuzugreifen Services API für 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. Initialisierung von LiteRT hinzufügen
LiteRT-Komponente der Google Play Services API initialisieren bevor Sie die LiteRT APIs verwenden:
Kotlin
val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }
Java
Task<Void> initializeTask = TfLite.initialize(context);
3. Interpreter erstellen und Laufzeitoption festlegen
Mit InterpreterApi.create()
einen Dolmetscher erstellen und für die Verwendung konfigurieren
Laufzeit der Google Play-Dienste durch Aufrufen von InterpreterApi.Options.setRuntime()
Dies wird im folgenden Beispielcode gezeigt:
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())); });
Sie sollten die obige Implementierung verwenden, da dadurch verhindert wird, dass das Android-
Benutzeroberflächen-Threads. Wenn Sie die Thread-Ausführung
genauer verwalten müssen,
kann einen Tasks.await()
-Aufruf zum Erstellen des Dolmetschers hinzufügen:
Kotlin
import androidx.lifecycle.lifecycleScope ... lifecycleScope.launchWhenStarted { // uses coroutine initializeTask.await() }
Java
@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.
Kotlin
interpreter.run(inputBuffer, outputBuffer)
Java
interpreter.run(inputBuffer, outputBuffer);
Hardwarebeschleunigung
Mit LiteRT können Sie die Leistung Ihres Modells mithilfe von Spezialisierte Hardwareprozessoren wie GPUs (Graphics Processing Units) Ich können diese speziellen Prozessoren mithilfe von Hardwaretreibern nutzen, Bevollmächtigten.
Der GPU Delegate wird über die Google Play-Dienste bereitgestellt. und dynamisch geladen werden, genau wie die Play-Dienste-Versionen Interpreter API.
Gerätekompatibilität wird geprüft
Nicht alle Geräte unterstützen die GPU-Hardwarebeschleunigung mit TFLite. Um
Fehler und potenzielle Abstürze zu minimieren, verwenden Sie
TfLiteGpu.isGpuDelegateAvailable
-Methode zu prüfen, ob ein Gerät
ist mit dem GPU-Delegaten kompatibel.
Mit dieser Methode prüfen, ob ein Gerät mit der GPU kompatibel ist, und die CPU verwenden als Fallback, wenn die GPU nicht unterstützt wird.
useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)
Sobald Sie eine Variable wie useGpuTask
haben, können Sie damit bestimmen,
Geräte den GPU-Delegaten verwenden.
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 mit Interpreter APIs
So verwenden Sie den GPU-Delegaten mit den Interpreter APIs:
Aktualisieren Sie die Projektabhängigkeiten, um den GPU-Delegaten aus den Play-Diensten zu verwenden:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
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());
GPU Delegate in den Interpreter-Optionen aktivieren: Setze die Delegate Factory auf GpuDelegateFactory durch Aufrufen von
addDelegateFactory() within
InterpreterApi.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());
Von eigenständigem LiteRT migrieren
Wenn Sie vorhaben, Ihre App vom eigenständigen LiteRT zur Version Play Services API haben, lesen Sie die folgenden zusätzlichen Informationen zur Aktualisierung der App-Projektcode:
- Überprüfen Sie den Abschnitt Einschränkungen auf dieser Seite, um sicherzustellen, Anwendungsfall unterstützt.
- Führen Sie vor der Aktualisierung Ihres Codes Leistungs- und Genauigkeitsprüfungen für Ihre insbesondere wenn Sie ältere LiteRT-Versionen verwenden, als Version 2.1. So haben Sie eine Referenz, die Sie mit der neuen Version vergleichen können, Implementierung.
- Wenn Sie Ihren gesamten Code migriert haben, um die Play Services API für
LiteRT sollten Sie die vorhandene LiteRT--Laufzeit entfernen.
Library-Abhängigkeiten (Einträge mit
org.tensorflow:tensorflow-lite:*
) aus Ihrer build.gradle-Datei -Datei, um die App-Größe zu reduzieren. - Identifizieren Sie alle Vorkommen der
new Interpreter
-Objekterstellung in Ihrem Code. und ändern Sie jede so, dass sie den Aufruf „InterpreterApi.create()“ verwendet. Die "new TfLite.initial" ist asynchron. Das heißt, in den meisten Fällen ist es kein Drop-in-Ersatz: Sie müssen einen Listener registrieren, wenn der Aufruf abgeschlossen wird. Sehen Sie sich das Code-Snippet im Code in Schritt 3 an. import org.tensorflow.lite.InterpreterApi;
undimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
zu einer beliebigen Quelle hinzufügen mit der Methodeorg.tensorflow.lite.Interpreter
oderorg.tensorflow.lite.InterpreterApi
Klassen.- Wenn einer der resultierenden
InterpreterApi.create()
-Aufrufe nur einen einzelnes Argument, fügen Sienew InterpreterApi.Options()
an die Argumentliste an. - Hängen Sie
.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
an das letzte Argument von an: alle Aufrufe vonInterpreterApi.create()
. - Alle anderen Vorkommen der Klasse
org.tensorflow.lite.Interpreter
ersetzen mitorg.tensorflow.lite.InterpreterApi
.
Wenn Sie die eigenständige LiteRT API und die Play Services API verwenden möchten nebeneinander ausführen, müssen Sie LiteRT 2.9 (oder höher) verwenden. LiteRT 2.8 und frühere Versionen sind nicht mit der Play Services API-Version kompatibel.