Como usar unidades de processamento gráfico (GPUs) para executar modelos de machine learning (ML) pode melhorar drasticamente o desempenho e a experiência do usuário do seu os aplicativos habilitados para ML. Em dispositivos Android, é possível ativar delegate e uma das seguintes APIs:
- API Interpreter - este guia
- API nativa (C/C++): guia
Esta página descreve como ativar a aceleração de GPU para modelos LiteRT em Apps Android que usam a API Interpreter. Para mais informações sobre como usar a GPU da LiteRT, incluindo práticas recomendadas e técnicas avançadas, consulte a página de delegados de GPU.
Usar a GPU com o LiteRT com o Google Play Services
O intérprete do LiteRT API oferece um conjunto de APIs de uso geral para a criação de aplicativos de machine learning. Esta seção descreve como usar o delegado do acelerador de GPU com essas APIs com LiteRT com o Google Play Services.
LiteRT com Google Play Services é a opção recomendada para usar o LiteRT no Android. Caso seu aplicativo esteja direcionado a dispositivos ainda não executando o Google Play, consulte a GPU com API Interpreter e LiteRT.
Adicionar dependências do projeto (com o catálogo de versões .toml)
- Atualizar o arquivo
libs.versions.toml
do seu projeto
[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" }
...
- Adicionar dependências do projeto no
build.gradle.kts
do app
dependencies {
...
implementation(libraries.tflite.gpu)
implementation(libraries.tflite.gpu.api)
...
}
Adicionar dependências do projeto
Para permitir o acesso ao delegado da GPU, adicione
com.google.android.gms:play-services-tflite-gpu
para o build.gradle
do seu app
arquivo:
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'
}
Ativar aceleração de GPU
Em seguida, inicialize o LiteRT com o Google Play Services compatível com GPUs:
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()); });
Você pode finalmente inicializar o intérprete transmitindo um GpuDelegateFactory
até 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);
O delegado da GPU também pode ser usado com vinculação de modelos de ML no Android Studio. Para mais informações, consulte Gerar interfaces de modelo usando metadados.
Usar a GPU com o LiteRT independente
Caso seu aplicativo seja destinado a dispositivos que não executam o Google Play, ele é possível agrupar o delegado da GPU em seu aplicativo e usá-lo com o uma versão independente do LiteRT.
Adicionar dependências do projeto
Para permitir o acesso ao delegado da GPU, adicione
com.google.ai.edge.litert:litert-gpu-delegate-plugin
para o
Arquivo build.gradle
:
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite'
implementation 'com.google.ai.edge.litert:litert-gpu-delegate-plugin'
}
Ativar aceleração de GPU
Em seguida, execute o LiteRT na GPU com TfLiteDelegate
. No Java, é possível especificar
o GpuDelegate
pelo 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 quantizados
As bibliotecas de delegação de GPU do Android oferecem suporte a modelos quantizados por padrão. Você não precisará fazer alterações no código para usar modelos quantizados com o delegado da GPU. A seção a seguir explica como desativar o suporte quantizado para testes ou para fins experimentais.
Desativar o suporte a modelos quantizados
O código a seguir mostra como desativar o suporte a modelos quantizados.
Java
GpuDelegate delegate = new GpuDelegate(new GpuDelegate.Options().setQuantizedModelsAllowed(false)); Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
Para mais informações sobre como executar modelos quantizados com aceleração de GPU, consulte Visão geral do delegado da GPU.