L'utilisation d'unités de traitement graphique (GPU) pour exécuter vos modèles d'apprentissage automatique (ML) peut améliorer considérablement les performances de votre modèle et l'expérience utilisateur de vos applications compatibles ML. Sur les appareils Android, vous pouvez activer l'utilisation de l'exécution accélérée par GPU de vos modèles à l'aide d'un délégué . Les délégués agissent en tant que pilotes matériels pour TensorFlow Lite, vous permettant d'exécuter le code de votre modèle sur des processeurs GPU.
Cette page explique comment activer l'accélération GPU pour les modèles TensorFlow Lite dans les applications Android. Pour plus d'informations sur l'utilisation du délégué GPU pour TensorFlow Lite, y compris les bonnes pratiques et les techniques avancées, consultez la page des délégués GPU .
Utiliser le GPU avec les API de la bibliothèque de tâches
Les bibliothèques de tâches TensorFlow Lite fournissent un ensemble d'API spécifiques aux tâches pour créer des applications de machine learning. Cette section décrit comment utiliser le délégué de l'accélérateur GPU avec ces API.
Ajouter des dépendances de projet
Activez l'accès aux API déléguées GPU avec les bibliothèques de tâches TensorFlow Lite en ajoutant les dépendances suivantes. Mettez à jour le fichier build.gradle
de vos projets de développement pour inclure le tensorflow-lite-gpu-delegate-plugin
, comme illustré dans l'exemple de code suivant :
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}
Activer l'accélération GPU
Activez l'option de délégué GPU pour votre classe de modèle d'API de tâche avec la classe BaseOptions
. Par exemple, vous pouvez configurer le GPU dans ObjectDetector
comme indiqué dans les exemples de code suivants :
Kotlin
import org.tensorflow.lite.task.core.BaseOptions import org.tensorflow.lite.task.gms.vision.detector.ObjectDetector val baseOptions = BaseOptions.builder().useGpu().build() val options = ObjectDetector.ObjectDetectorOptions.builder() .setBaseOptions(baseOptions) .setMaxResults(1) .build() val objectDetector = ObjectDetector.createFromFileAndOptions( context, model, options)
Java
import org.tensorflow.lite.task.core.BaseOptions import org.tensorflow.lite.task.gms.vision.detector.ObjectDetector BaseOptions baseOptions = BaseOptions.builder().useGpu().build(); ObjectDetectorOptions options = ObjectDetectorOptions.builder() .setBaseOptions(baseOptions) .setMaxResults(1) .build(); val objectDetector = ObjectDetector.createFromFileAndOptions( context, model, options);
Utiliser le GPU avec l'API Interpreter
L' API TensorFlow Lite Interpreter fournit un ensemble d'API à usage général pour créer des applications d'apprentissage automatique. Cette section décrit comment utiliser le délégué de l'accélérateur GPU avec ces API.
Ajouter des dépendances de projet
Activez l'accès aux API déléguées GPU en ajoutant les dépendances suivantes, mettez à jour le fichier build.gradle
de vos projets de développement pour inclure le org.tensorflow:tensorflow-lite-gpu
, comme illustré dans l'exemple de code suivant :
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite'
implementation 'org.tensorflow:tensorflow-lite-gpu'
}
Activer l'accélération GPU
Exécutez ensuite TensorFlow Lite sur GPU avec TfLiteDelegate
. En Java, vous pouvez spécifier le GpuDelegate
via 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);
Le délégué GPU peut également être utilisé avec la liaison de modèle ML dans Android Studio. Pour plus d'informations, consultez Générer des interfaces de modèle à l'aide de métadonnées .
Prise en charge avancée du processeur graphique
Cette section couvre les utilisations avancées du délégué GPU pour Android, y compris l'API C, l'API C++ et l'utilisation de modèles quantifiés.
API C/C++ pour Android
Utilisez le délégué GPU TensorFlow Lite pour Android en C ou C++ en créant le délégué avec TfLiteGpuDelegateV2Create()
et en le détruisant avec TfLiteGpuDelegateV2Delete()
, comme illustré dans l'exemple de code suivant :
// Set up interpreter.
auto model = FlatBufferModel::BuildFromFile(model_path);
if (!model) return false;
ops::builtin::BuiltinOpResolver op_resolver;
std::unique_ptr<Interpreter> interpreter;
InterpreterBuilder(*model, op_resolver)(&interpreter);
// NEW: Prepare GPU delegate.
auto* delegate = TfLiteGpuDelegateV2Create(/*default options=*/nullptr);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
// Run inference.
WriteToInputTensor(interpreter->typed_input_tensor<float>(0));
if (interpreter->Invoke() != kTfLiteOk) return false;
ReadFromOutputTensor(interpreter->typed_output_tensor<float>(0));
// NEW: Clean up.
TfLiteGpuDelegateV2Delete(delegate);
Passez en revue le code objet TfLiteGpuDelegateOptionsV2
pour créer une instance déléguée avec des options personnalisées. Vous pouvez initialiser les options par défaut avec TfLiteGpuDelegateOptionsV2Default()
puis les modifier si nécessaire.
Le délégué GPU TensorFlow Lite pour Android en C ou C++ utilise le système de génération Bazel . Vous pouvez créer le délégué à l'aide de la commande suivante :
bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:delegate # for static library
bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:libtensorflowlite_gpu_delegate.so # for dynamic library
Lors de l'appel Interpreter::ModifyGraphWithDelegate()
ou Interpreter::Invoke()
, l'appelant doit avoir un EGLContext
dans le thread actuel et Interpreter::Invoke()
doit être appelé à partir du même EGLContext
. Si un EGLContext
n'existe pas, le délégué en crée un en interne, mais vous devez alors vous assurer que Interpreter::Invoke()
est toujours appelé à partir du même thread dans lequel Interpreter::ModifyGraphWithDelegate()
a été appelé.
Modèles quantifiés
Les bibliothèques déléguées de GPU Android prennent en charge les modèles quantifiés par défaut. Vous n'avez pas besoin d'apporter de modifications au code pour utiliser des modèles quantifiés avec le délégué GPU. La section suivante explique comment désactiver la prise en charge quantifiée à des fins de test ou d'expérimentation.
Désactiver la prise en charge du modèle quantifié
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);
C++
TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default(); options.experimental_flags = TFLITE_GPU_EXPERIMENTAL_FLAGS_NONE; auto* delegate = TfLiteGpuDelegateV2Create(options); if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
Pour plus d'informations sur l'exécution de modèles quantifiés avec l'accélération GPU, consultez Présentation du délégué GPU .