LiteRT na API Google Play Services Java (e Kotlin)

O LiteRT nos Serviços do Google Play também pode ser acessado usando APIs Java, que podem ser usadas em código Java ou Kotlin, além da API nativa. Especificamente, a LiteRT no Google Play Services está disponível pela API LiteRT Interpreter (em inglês).

Como usar as APIs Interpreter

A API LiteRT Interpreter, fornecida pelo ambiente de execução do TensorFlow, oferece 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 dependências a seguir ao código do projeto do app para acessar a API Play Services para LiteRT:

dependencies {
...
    // LiteRT dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.1.0'
    // Optional: include LiteRT Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.1.0'
...
}

2. Adicionar a inicialização do LiteRT

Inicialize o componente LiteRT da API Google Play Services antes de usar as APIs LiteRT:

Kotlin

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

Java

Task<Void> initializeTask = TfLite.initialize(context);

3. Criar um intérprete e definir a opção de execução

Crie um interpretador 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 para evitar o bloqueio da linha de execução da interface do usuário do Android. Se você precisar gerenciar a execução de linhas de execução mais de perto, adicione uma chamada Tasks.await() à criação do interpretador:

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 que você criou, chame o método run() para gerar uma inferência.

Kotlin

interpreter.run(inputBuffer, outputBuffer)

Java

interpreter.run(inputBuffer, outputBuffer);

Aceleração de hardware

A LiteRT permite que você acelere o desempenho do seu modelo usando processadores de hardware especializados, como unidades de processamento gráfico (GPUs). É possível aproveitar esses processadores especializados usando drivers de hardware chamados delegates.

O delegação de GPU é fornecido pelo Google Play Services e carregado dinamicamente, assim como as versões do Google Play Services da API Interpreter.

Como verificar 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 de GPU.

Use esse método para confirmar se um dispositivo é compatível com a GPU e use a CPU como substituto quando a GPU não tiver suporte.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Depois de ter uma variável como useGpuTask, você pode usá-la para determinar se os dispositivos usam o delegado de 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 intérprete

Para usar o delegado de GPU com as APIs Interpreter:

  1. Atualize as dependências do projeto para usar o delegado da GPU do Google Play Services:

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'

  2. Ative a opção de delegação de 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 de GPU nas opções do interpretador: defina a fábrica de delegados 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 da versão autônoma do LiteRT

Se você planeja migrar seu app do LiteRT independente para a API Play Services, leia as orientações a seguir 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 tenha suporte.
  2. Antes de atualizar o código, recomendamos fazer verificações de desempenho e precisão dos modelos, principalmente se você estiver usando versões do LiteRT (TF Lite) anteriores à versão 2.1, para ter uma referência para comparar com a nova implementação.
  3. Se você migrou todo o código para usar a API Play Services para LiteRT, remova as dependências da biblioteca de execução do LiteRT (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 do objeto new Interpreter no seu código e modifique cada uma para que ele 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 direta: é necessário registrar um listener para quando a chamada for concluída. Consulte o snippet de código na Etapa 3.
  5. Adicione import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a todos os arquivos 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 qualquer chamada 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 LiteRT independente e a API Google Play Services ao mesmo tempo, use o LiteRT (TF Lite) versão 2.9 ou mais recente. A versão 2.8 e anteriores do LiteRT (TF Lite) não são compatíveis com a versão da API Play Services.