L'utilisation de processeurs graphiques (GPU) pour exécuter vos modèles de machine learning (ML) peut considérablement améliorer les performances et l'expérience utilisateur de vos applications compatibles avec le ML. Sur les appareils Android, vous pouvez activer un délégué et l'une des API suivantes:
- API Interprète – ce guide
- API native (C/C++) : guide
Cette page explique comment activer l'accélération du GPU pour les modèles TensorFlow Lite dans les applications Android à l'aide de l'API Interpréteur. Pour en savoir plus sur l'utilisation du délégué de GPU pour TensorFlow Lite, y compris sur les bonnes pratiques et les techniques avancées, consultez la page Délégués de GPU.
Utiliser un GPU avec TensorFlow Lite avec les services Google Play
L'API Interpréteur TensorFlow Lite fournit un ensemble d'API à usage général pour la création d'applications de machine learning. Cette section explique comment utiliser le délégué d'accélérateur GPU avec ces API avec TensorFlow Lite avec les services Google Play.
Pour utiliser TensorFlow Lite sur Android, nous vous recommandons d'utiliser TensorFlow Lite avec les services Google Play. Si votre application cible les appareils qui n'exécutent pas Google Play, consultez la section GPU avec l'API Interpréteur et la version autonome de TensorFlow Lite.
Ajouter des dépendances de projet (avec le catalogue de versions .toml)
- Mettre à jour le fichier
libs.versions.toml
de votre projet
[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" }
...
- Ajouter des dépendances de projet dans le fichier
build.gradle.kts
de l'application
dependencies {
...
implementation(libraries.tflite.gpu)
implementation(libraries.tflite.gpu.api)
...
}
Ajouter des dépendances au projet
Pour activer l'accès au délégué GPU, ajoutez com.google.android.gms:play-services-tflite-gpu
au fichier build.gradle
de votre application:
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'
}
Activer l'accélération du GPU
Ensuite, initialisez TensorFlow Lite avec les services Google Play compatibles avec les GPU:
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()); });
Vous pouvez enfin initialiser l'interpréteur en transmettant un GpuDelegateFactory
via 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);
Le délégué GPU peut également être utilisé avec la liaison de modèles de ML dans Android Studio. Pour en savoir plus, consultez la section Générer des interfaces de modèle à l'aide de métadonnées.
Utiliser un GPU avec la version autonome de TensorFlow Lite
Si votre application cible des appareils qui n'exécutent pas Google Play, il est possible de regrouper le délégué GPU à votre application et de l'utiliser avec la version autonome de TensorFlow Lite.
Ajouter des dépendances au projet
Pour activer l'accès au délégué GPU, ajoutez org.tensorflow:tensorflow-lite-gpu-delegate-plugin
au fichier build.gradle
de votre application:
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite'
implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}
Activer l'accélération du GPU
Exécutez ensuite TensorFlow Lite sur un GPU avec TfLiteDelegate
. En Java, vous pouvez spécifier de GpuDelegate
à 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);
Modèles quantifiés
Par défaut, les bibliothèques de délégués de GPU Android sont compatibles avec les modèles quantifiés. Vous n'avez pas besoin de modifier le code pour utiliser des modèles quantifiés avec le délégué GPU. La section suivante explique comment désactiver la compatibilité quantifiée à des fins de test ou d'expérimentation.
Désactiver la prise en charge des modèles quantifiés
Le code suivant montre comment désactiver la prise en charge des modèles quantifiés.
Java
GpuDelegate delegate = new GpuDelegate(new GpuDelegate.Options().setQuantizedModelsAllowed(false)); Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
Pour en savoir plus sur l'exécution de modèles quantifiés avec l'accélération GPU, consultez la section Délégué de GPU.