Utiliser des 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 les applications compatibles avec le ML. Sur les appareils Android, vous pouvez activer delegate et l'une des API suivantes:
- API Interpreter : ce guide
- API native (C/C++) : guide
Cette page explique comment activer l'accélération GPU pour les modèles LiteRT dans Applications Android utilisant l'API Interpreter Pour en savoir plus sur l'utilisation du GPU pour LiteRT, y compris les bonnes pratiques et les techniques avancées, consultez la page Délégués de GPU.
Utiliser le GPU avec LiteRT avec les services Google Play
L'interprète LiteRT de l'API Google fournit un ensemble des API à usage général pour créer des applications de machine learning. Cette section explique comment utiliser le délégué de l'accélérateur GPU avec ces API avec avec les services Google Play.
Nous vous recommandons d'utiliser LiteRT avec les services Google Play. pour utiliser LiteRT sur Android. Si votre application cible les appareils qui n'est pas exécutée sur Google Play, consultez l'article GPU avec API Interpreter et LiteRT.
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 = "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" }
...
- 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 de projet
Pour activer l'accès au délégué de GPU, ajoutez
com.google.android.gms:play-services-tflite-gpu
à la 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 GPU
Ensuite, initialisez LiteRT 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
à 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é de GPU peut également être utilisé avec la liaison de modèle 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 le GPU avec la version LiteRT autonome
Si votre application cible des appareils qui n'exécutent pas Google Play, elle est de grouper le délégué GPU avec votre application et de l'utiliser avec le la version autonome de LiteRT.
Ajouter des dépendances de projet
Pour activer l'accès au délégué de GPU, ajoutez
com.google.ai.edge.litert:litert-gpu-delegate-plugin
à votre
Fichier build.gradle
:
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite'
implementation 'com.google.ai.edge.litert:litert-gpu-delegate-plugin'
}
Activer l'accélération GPU
Exécutez ensuite LiteRT 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 déléguées de GPU Android sont compatibles avec les modèles quantifiés. Vous ne devez pas n'avez pas besoin de modifier le code pour utiliser des modèles quantifiés avec le délégué de GPU. La La section suivante explique comment désactiver la prise en charge quantifiée pour les tests ou à des fins expérimentales.
Désactiver la compatibilité avec les 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 Présentation de la délégué de GPU.