O TensorFlow Lite no Google Play Services também pode ser acessado usando APIs Java, além da API Native. Mais especificamente, o TensorFlow Lite no Google Play Services está disponível pela API TensorFlow Lite Interpreter.
Como usar as APIs Interpreter
A API Interpreter do TensorFlow Lite, fornecida pelo ambiente de execução do TensorFlow, fornece uma interface de uso geral para criar e executar modelos de ML. Siga as etapas abaixo para executar inferências com a API Interpreter usando o TensorFlow Lite no ambiente de execução do Google Play Services.
1. Adicionar dependências do projeto
Adicione as seguintes dependências ao código do projeto do app para acessar a API Play Services para o TensorFlow Lite:
dependencies {
...
// Tensorflow Lite dependencies for Google Play services
implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
// Optional: include Tensorflow Lite Support Library
implementation 'com.google.android.gms:play-services-tflite-support:16.0.1'
...
}
2. Adicionar a inicialização do TensorFlow Lite
Inicialize o componente TensorFlow Lite da API Google Play Services antes de usar as APIs do TensorFlow Lite:
Kotlin
val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }
Java
Task<Void> initializeTask = TfLite.initialize(context);
3. Criar um intérprete e definir uma opção de ambiente de execução
Crie um intérprete usando InterpreterApi.create()
e configure-o para usar o
ambiente de execução do Google Play Services chamando InterpreterApi.Options.setRuntime()
,
conforme mostrado no código de exemplo a seguir:
Kotlin
import org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime ... private lateinit var interpreter: InterpreterApi ... initializeTask.addOnSuccessListener { val interpreterOption = InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) interpreter = InterpreterApi.create( modelBuffer, interpreterOption )} .addOnFailureListener { e -> Log.e("Interpreter", "Cannot initialize interpreter", e) }
Java
import org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime ... private InterpreterApi interpreter; ... initializeTask.addOnSuccessListener(a -> { interpreter = InterpreterApi.create(modelBuffer, new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)); }) .addOnFailureListener(e -> { Log.e("Interpreter", String.format("Cannot initialize interpreter: %s", e.getMessage())); });
Use a implementação acima porque ela evita o bloqueio da linha de execução
da interface do usuário do Android. Se você precisar gerenciar a execução da linha de execução mais de perto, adicione uma chamada Tasks.await()
para a criação de intérpretes:
Kotlin
import androidx.lifecycle.lifecycleScope ... lifecycleScope.launchWhenStarted { // uses coroutine initializeTask.await() }
Java
@BackgroundThread InterpreterApi initializeInterpreter() { Tasks.await(initializeTask); return InterpreterApi.create(...); }
4. Executar inferências
Usando o objeto interpreter
criado, chame o método run()
para gerar
uma inferência.
Kotlin
interpreter.run(inputBuffer, outputBuffer)
Java
interpreter.run(inputBuffer, outputBuffer);
Aceleração de hardware
O TensorFlow Lite permite acelerar o desempenho do seu modelo usando processadores de hardware especializados, como unidades de processamento gráfico (GPUs). Você pode aproveitar esses processadores especializados usando drivers de hardware chamados delegados.
O delegado de GPU é fornecido pelo Google Play Services e é carregado dinamicamente, assim como as versões do Google Play Services da API Interpreter.
Verificando a compatibilidade do dispositivo
Nem todos os dispositivos oferecem suporte à aceleração de hardware da GPU com o TFLite. Para
mitigar erros e possíveis falhas, use o método
TfLiteGpu.isGpuDelegateAvailable
para verificar se um dispositivo é
compatível com o delegado da GPU.
Use esse método para confirmar se um dispositivo é compatível com GPU e use a CPU como substituto quando ela não tiver suporte.
useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)
Quando você tiver uma variável como useGpuTask
, poderá usá-la para determinar se
os dispositivos usam o delegado da GPU.
Kotlin
val interpreterTask = useGpuTask.continueWith { task -> val interpreterOptions = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) if (task.result) { interpreterOptions.addDelegateFactory(GpuDelegateFactory()) } InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions) }
Java
Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task -> InterpreterApi.Options options = new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY); if (task.getResult()) { options.addDelegateFactory(new GpuDelegateFactory()); } return options; });
GPU com APIs de interpretação
Para usar o delegado de GPU com as APIs do intérprete:
Atualize as dependências do projeto para usar o delegado de GPU do Google Play Services:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
Ative a opção de delegação da GPU na inicialização do TFlite:
Kotlin
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build())
Java
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build());
Ative o delegado da GPU nas opções do intérprete: defina a fábrica do delegado como GpuDelegateFactory chamando
addDelegateFactory() within
InterpreterApi.Options()`:Kotlin
val interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(GpuDelegateFactory())
Java
Options interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(new GpuDelegateFactory());
Como migrar do TensorFlow Lite independente
Se você planeja migrar seu app do TensorFlow Lite independente para a API Play Services, consulte as seguintes orientações para atualizar o código do projeto do app:
- Consulte a seção Limitações desta página para garantir que seu caso de uso seja aceito.
- Antes de atualizar o código, realize verificações de desempenho e precisão nos modelos, especialmente se você estiver usando versões do TensorFlow Lite anteriores à versão 2.1. Assim, você terá um valor de referência para comparar com a nova implementação.
- Se você migrou todo o código para usar a API Play Services para
o TensorFlow Lite, remova as dependências da biblioteca
de ambiente de execução do TensorFlow Lite (entradas com
org.tensorflow:tensorflow-lite:*
) do arquivo build.gradle para reduzir o tamanho do app. - Identifique todas as ocorrências de criação de objetos
new Interpreter
no seu código e modifique cada uma para que use a chamada InterpreterApi.create(). O novo TfLite.Initialize é assíncrono, o que significa que, na maioria dos casos, ele não é uma substituição simples: você precisa registrar um listener para quando a chamada for concluída. Consulte o snippet de código no código da Etapa 3. - Adicione
import org.tensorflow.lite.InterpreterApi;
eimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
a qualquer arquivo de origem usando as classesorg.tensorflow.lite.Interpreter
ouorg.tensorflow.lite.InterpreterApi
. - Se alguma das chamadas resultantes para
InterpreterApi.create()
tiver apenas um argumento, anexenew InterpreterApi.Options()
à lista de argumentos. - Anexe
.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
ao último argumento de todas as chamadas paraInterpreterApi.create()
. - Substitua todas as outras ocorrências da classe
org.tensorflow.lite.Interpreter
pororg.tensorflow.lite.InterpreterApi
.
Se você quiser usar o TensorFlow Lite independente e a API Play Services lado a lado, use o TensorFlow Lite 2.9 (ou mais recente). O TensorFlow Lite 2.8 e as versões anteriores não são compatíveis com a versão da API Play Services.