Die Verwendung von Grafikprozessoren (GPUs) zum Ausführen Ihrer Modelle für maschinelles Lernen (ML) kann die Leistung und Nutzerfreundlichkeit Ihrer ML-fähigen Anwendungen erheblich verbessern. Auf Android-Geräten können Sie einen Bevollmächtigten und eine der folgenden APIs aktivieren:
- Interpreter API – dieser Leitfaden
- Native API (C/C++) – Anleitung
Auf dieser Seite wird beschrieben, wie Sie die GPU-Beschleunigung für TensorFlow Lite-Modelle in Android-Apps mithilfe der Interpreter API aktivieren. Weitere Informationen zur Verwendung des GPU-Bevollmächtigten für TensorFlow Lite, einschließlich Best Practices und erweiterter Techniken, finden Sie auf der Seite GPU-Bevollmächtigte.
GPU mit TensorFlow Lite mit Google Play-Diensten verwenden
Die Interpreter API von TensorFlow Lite bietet eine Reihe von allgemeinen APIs zum Erstellen von Anwendungen für maschinelles Lernen. In diesem Abschnitt wird beschrieben, wie Sie den GPU-Beschleuniger-Delegaten mit diesen APIs in TensorFlow Lite mit Google Play-Diensten verwenden.
TensorFlow Lite mit Google Play-Diensten ist der empfohlene Pfad für die Verwendung von TensorFlow Lite unter Android. Wenn Ihre App auf Geräte ausgerichtet ist, auf denen Google Play nicht ausgeführt wird, lesen Sie den Abschnitt GPU mit Interpreter API und eigenständigem TensorFlow Lite.
Projektabhängigkeiten hinzufügen (mit .toml-Versionskatalog)
libs.versions.toml
-Datei Ihres Projekts aktualisieren
[libraries]
...
tflite-gpu = { module = "org.tensorflow:tensorflow-lite-gpu", version = "2.X.Y" }
tflite-gpu-api = { module = "org.tensorflow:tensorflow-lite-gpu-api", version = "2.X.Y" }
...
- Projektabhängigkeiten in der
build.gradle.kts
der Anwendung hinzufügen
dependencies {
...
implementation(libraries.tflite.gpu)
implementation(libraries.tflite.gpu.api)
...
}
Projektabhängigkeiten hinzufügen
Fügen Sie der Datei build.gradle
Ihrer Anwendung com.google.android.gms:play-services-tflite-gpu
hinzu, um den Zugriff auf den GPU-Delegaten zu aktivieren:
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 TensorFlow Lite mit den Google Play-Diensten mit der 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()); });
Sie können den Interpreter initialisieren und GpuDelegateFactory
über InterpreterApi.Options
übergeben:
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. Weitere Informationen finden Sie unter Modellschnittstellen mit Metadaten generieren.
GPU mit eigenständigem TensorFlow Lite verwenden
Wenn Ihre Anwendung auf Geräte ausgerichtet ist, auf denen Google Play nicht ausgeführt wird, ist es möglich, den GPU-Delegaten zu Ihrer Anwendung zu bündeln und mit der eigenständigen Version von TensorFlow Lite zu verwenden.
Projektabhängigkeiten hinzufügen
Fügen Sie der Datei build.gradle
Ihrer Anwendung org.tensorflow:tensorflow-lite-gpu-delegate-plugin
hinzu, um den Zugriff auf den GPU-Delegaten zu aktivieren:
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite'
implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}
GPU-Beschleunigung aktivieren
Führen Sie dann TensorFlow Lite mit TfLiteDelegate
auf der GPU aus. In Java können Sie GpuDelegate
bis Interpreter.Options
angeben.
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-Delegierungsbibliotheken unterstützen standardmäßig quantisierte Modelle. Sie müssen keine Codeänderungen vornehmen, um quantisierte Modelle mit dem GPU-Delegaten zu verwenden. Im folgenden Abschnitt wird erläutert, wie Sie die quantisierte Unterstützung für Test- oder experimentelle Zwecke deaktivieren.
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 in der Übersicht zum GPU-Delegaten.