El uso de unidades de procesamiento gráfico (GPU) para ejecutar tus modelos de aprendizaje automático (AA) puede mejorar drásticamente el rendimiento y la experiencia del usuario de las aplicaciones habilitadas para el AA. En dispositivos Android, puedes habilitar un delegado y una de las siguientes APIs:
- API de intérprete: esta guía
- API nativa (C/C++): guía
En esta página, se describe cómo habilitar la aceleración de GPU para modelos de TensorFlow Lite en apps para Android que usan la API de intérprete. Para obtener más información sobre el uso del delegado de GPU para TensorFlow Lite, incluidas las prácticas recomendadas y las técnicas avanzadas, consulta la página Delegados de GPU.
Usa GPU con TensorFlow Lite con los Servicios de Google Play
La API de Interpreter de TensorFlow Lite proporciona un conjunto de API de uso general para compilar aplicaciones de aprendizaje automático. En esta sección, se describe cómo usar el delegado del acelerador de GPU con estas APIs en TensorFlow Lite con los Servicios de Google Play.
TensorFlow Lite con los Servicios de Google Play es la ruta recomendada para usar TensorFlow Lite en Android. Si tu aplicación está orientada a dispositivos que no ejecutan Google Play, consulta la sección GPU con la API de intérprete y TensorFlow Lite independiente.
Agrega dependencias del proyecto (con un catálogo de versiones en .toml)
- Actualiza el archivo
libs.versions.toml
de tu proyecto
[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" }
...
- Agrega dependencias de proyecto en el
build.gradle.kts
de la app
dependencies {
...
implementation(libraries.tflite.gpu)
implementation(libraries.tflite.gpu.api)
...
}
Agrega dependencias del proyecto
Para habilitar el acceso al delegado de la GPU, agrega com.google.android.gms:play-services-tflite-gpu
al archivo build.gradle
de tu app:
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'
}
Cómo habilitar la aceleración de GPU
Luego, inicializa TensorFlow Lite con los Servicios de Google Play compatibles con 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()); });
Por último, puedes inicializar el intérprete pasando un GpuDelegateFactory
a través de 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);
El delegado de la GPU también se puede usar con la vinculación de modelos de AA en Android Studio. Para obtener más información, consulta Cómo generar interfaces de modelos con metadatos.
Usa GPU con TensorFlow Lite independiente
Si tu aplicación se orienta a dispositivos que no ejecutan Google Play, es posible empaquetar el delegado de la GPU a tu aplicación y usarlo con la versión independiente de TensorFlow Lite.
Agrega dependencias del proyecto
Para habilitar el acceso al delegado de la GPU, agrega org.tensorflow:tensorflow-lite-gpu-delegate-plugin
al archivo build.gradle
de tu app:
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite'
implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}
Cómo habilitar la aceleración de GPU
Luego, ejecuta TensorFlow Lite en la GPU con TfLiteDelegate
. En Java, puedes especificar GpuDelegate
a 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);
Modelos cuantificados
Las bibliotecas delegadas de GPU de Android admiten modelos cuantificados de forma predeterminada. No es necesario que realices ningún cambio en el código para usar modelos cuantizados con el delegado de GPU. En la siguiente sección, se explica cómo inhabilitar la compatibilidad cuantizada con fines experimentales o de prueba.
Inhabilita la compatibilidad con modelos cuantizados
En el siguiente código, se muestra cómo inhabilitar la compatibilidad con modelos cuantizados.
Java
GpuDelegate delegate = new GpuDelegate(new GpuDelegate.Options().setQuantizedModelsAllowed(false)); Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
Para obtener más información sobre cómo ejecutar modelos cuantizados con aceleración de GPU, consulta la descripción general del delegado de GPU.