TensorFlow Lite na API Java do Google Play Services

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:

val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }

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:

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)
  }

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:

import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}

@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.

interpreter.run(inputBuffer, outputBuffer)

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.

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)
}
    

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:

1. 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'
   

2. 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());
       

3. Ative o delegado da GPU nas opções do intérprete: defina a fábrica do delegado como GpuDelegateFactory chamando addDelegateFactory() withinInterpreterApi.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:

1. Consulte a seção Limitações desta página para garantir que seu caso de uso seja aceito.
2. 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.
3. 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.
4. 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.
5. Adicione import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a qualquer arquivo de origem usando as classes org.tensorflow.lite.Interpreter ou org.tensorflow.lite.InterpreterApi.
6. Se alguma das chamadas resultantes para InterpreterApi.create() tiver apenas um argumento, anexe new InterpreterApi.Options() à lista de argumentos.
7. Anexe .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) ao último argumento de todas as chamadas para InterpreterApi.create().
8. Substitua todas as outras ocorrências da classe org.tensorflow.lite.Interpreter por org.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.