Grafikprozessoren (Graphics Processing Units, GPUs) zum Ausführen Ihrer Modelle für maschinelles Lernen (ML) verwenden die Leistung und Nutzererfahrung Ihrer Anzeigen erheblich verbessern, ML-fähige Anwendungen Auf Android-Geräten können Sie delegate und eine der folgenden APIs:
- Interpreter API – dieser Leitfaden
- Native (C/C++) API – Leitfaden
Auf dieser Seite wird beschrieben, wie Sie die GPU-Beschleunigung für LiteRT-Modelle in Android-Apps, die die Interpreter API verwenden Weitere Informationen zur Verwendung der GPU an LiteRT delegieren, einschließlich Best Practices und fortgeschrittener Techniken, Weitere Informationen finden Sie auf der Seite GPU-Bevollmächtigte.
GPU mit LiteRT mit Google Play-Diensten verwenden
Der LiteRT-Interpreter API bietet eine Reihe von universelle APIs zum Erstellen von ML-Anwendungen entwickelt. Dieser Abschnitt wird beschrieben, wie Sie den GPU-Beschleunigerdelegat mit diesen APIs LiteRT mit Google Play-Diensten
Wir empfehlen LiteRT mit Google Play-Diensten zu verwenden. LiteRT unter Android nutzen. Wenn Ihre App auf Geräte ausgerichtet ist Google Play nicht ausführen, sehen Sie sich die GPU mit Interpreter API und der eigenständigen LiteRT lesen.
Projektabhängigkeiten hinzufügen (mit .toml-Versionskatalog)
- Datei
libs.versions.toml
Ihres Projekts aktualisieren
[libraries]
...
tflite-gpu = { module = "com.google.ai.edge.litert:litert-gpu", version = "2.X.Y" }
tflite-gpu-api = { module = "com.google.ai.edge.litert:litert-gpu-api", version = "2.X.Y" }
...
- Fügen Sie Projektabhängigkeiten in der Datei
build.gradle.kts
der Anwendung hinzu
dependencies {
...
implementation(libraries.tflite.gpu)
implementation(libraries.tflite.gpu.api)
...
}
Projektabhängigkeiten hinzufügen
Fügen Sie zum Aktivieren des Zugriffs auf den GPU-Delegaten
com.google.android.gms:play-services-tflite-gpu
zu build.gradle
deiner App
Datei:
dependencies {
...
implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
}
GPU-Beschleunigung aktivieren
Initialisieren Sie dann LiteRT mit den Google Play-Diensten mit GPU-Unterstützung:
Kotlin
val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context) val interpreterTask = useGpuTask.continueWith { useGpuTask -> TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(useGpuTask.result) .build()) }
Java
Task<boolean> useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context); Task<Options> interpreterOptionsTask = useGpuTask.continueWith({ task -> TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build()); });
Schließlich können Sie den Interpreter initialisieren, indem Sie GpuDelegateFactory
übergeben.
bis InterpreterApi.Options
:
Kotlin
val options = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(GpuDelegateFactory()) val interpreter = InterpreterApi(model, options) // Run inference writeToInput(input) interpreter.run(input, output) readFromOutput(output)
Java
Options options = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(new GpuDelegateFactory()); Interpreter interpreter = new InterpreterApi(model, options); // Run inference writeToInput(input); interpreter.run(input, output); readFromOutput(output);
Der GPU-Delegate kann auch mit ML-Modellbindung in Android Studio verwendet werden. Für Weitere Informationen finden Sie unter Generieren von Modellschnittstellen mit Metadaten.
GPU mit eigenständigem LiteRT verwenden
Wenn Ihre App auf Geräte ausgerichtet ist, auf denen Google Play nicht ausgeführt wird, den GPU-Delegaten für Ihre Anwendung zu bündeln und mit dem LiteRT-Version.
Projektabhängigkeiten hinzufügen
Fügen Sie zum Aktivieren des Zugriffs auf den GPU-Delegaten
com.google.ai.edge.litert:litert-gpu-delegate-plugin
zu deiner App
build.gradle
-Datei:
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite'
implementation 'com.google.ai.edge.litert:litert-gpu-delegate-plugin'
}
GPU-Beschleunigung aktivieren
Führen Sie dann LiteRT mit TfLiteDelegate
auf der GPU aus. In Java können Sie angeben,
GpuDelegate
bis Interpreter.Options
.
Kotlin
import org.tensorflow.lite.Interpreter import org.tensorflow.lite.gpu.CompatibilityList import org.tensorflow.lite.gpu.GpuDelegate val compatList = CompatibilityList() val options = Interpreter.Options().apply{ if(compatList.isDelegateSupportedOnThisDevice){ // if the device has a supported GPU, add the GPU delegate val delegateOptions = compatList.bestOptionsForThisDevice this.addDelegate(GpuDelegate(delegateOptions)) } else { // if the GPU is not supported, run on 4 threads this.setNumThreads(4) } } val interpreter = Interpreter(model, options) // Run inference writeToInput(input) interpreter.run(input, output) readFromOutput(output)
Java
import org.tensorflow.lite.Interpreter; import org.tensorflow.lite.gpu.CompatibilityList; import org.tensorflow.lite.gpu.GpuDelegate; // Initialize interpreter with GPU delegate Interpreter.Options options = new Interpreter.Options(); CompatibilityList compatList = CompatibilityList(); if(compatList.isDelegateSupportedOnThisDevice()){ // if the device has a supported GPU, add the GPU delegate GpuDelegate.Options delegateOptions = compatList.getBestOptionsForThisDevice(); GpuDelegate gpuDelegate = new GpuDelegate(delegateOptions); options.addDelegate(gpuDelegate); } else { // if the GPU is not supported, run on 4 threads options.setNumThreads(4); } Interpreter interpreter = new Interpreter(model, options); // Run inference writeToInput(input); interpreter.run(input, output); readFromOutput(output);
Quantisierte Modelle
Android GPU Delegate-Bibliotheken unterstützen standardmäßig quantisierte Modelle. Du nicht Änderungen am Code vornehmen, um quantisierte Modelle mit dem GPU-Delegaten zu verwenden. Die Im folgenden Abschnitt wird erläutert, wie Sie die quantisierte Unterstützung für Tests oder zu experimentellen Zwecken.
Unterstützung quantisierter Modelle deaktivieren
Der folgende Code zeigt, wie Sie die Unterstützung für quantisierte Modelle deaktivieren.
Java
GpuDelegate delegate = new GpuDelegate(new GpuDelegate.Options().setQuantizedModelsAllowed(false)); Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
Weitere Informationen zum Ausführen quantisierter Modelle mit GPU-Beschleunigung finden Sie unter GPU Delegate