LiteRT na API Java do Google Play Services

A LiteRT no Google Play Services também pode ser acessada usando APIs Java, no além da API nativa. Mais especificamente, LiteRT no Google Play serviços estão disponíveis por meio do Intérprete da LiteRT API.

Como usar as APIs Interpreter

A API LiteRT Interpreter, fornecida pelo ambiente de execução do TensorFlow, fornece uma interface de uso geral para criar e executar modelos de ML. Use o etapas a seguir para executar inferências com a API Interpreter usando o Lite no tempo 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 biblioteca Play API de serviços para LiteRT:

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

2. Adicionar 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 uma opção de ambiente de execução

Criar um intérprete usando InterpreterApi.create() e configurá-lo para usar O ambiente de execução do Google Play Services, chamando InterpreterApi.Options.setRuntime(), conforme mostrado neste código de exemplo:

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

O LiteRT permite acelerar a performance do modelo usando processadores de hardware especializados, como unidades de processamento gráfico (GPUs). Você podem aproveitar esses processadores especializados usando drivers de hardware chamados delega.

O delegado da GPU é fornecido pelo Google Play Services. e é carregado dinamicamente, assim como as versões do Google Play Services Interpreter API.

Como verificar a compatibilidade do dispositivo

Nem todos os dispositivos oferecem suporte à aceleração de hardware da GPU com o TFLite. Para reduzir erros e possíveis falhas, use o TfLiteGpu.isGpuDelegateAvailable para verificar se um dispositivo está compatíveis com o delegado da GPU.

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

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Quando você tiver uma variável como useGpuTask, poderá usá-la para determinar se 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 intérprete

Para usar o delegado de GPU com as APIs Interpreter:

  1. Atualize as dependências do projeto para usar o delegante 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 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 da GPU nas opções do interpretador: 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());

Migrar do LiteRT autônomo

Se você planeja migrar seu app do LiteRT independente para o API do Google Play Services, leia as orientações a seguir para atualizar seu código do projeto do aplicativo:

  1. Consulte a seção Limitações desta página para garantir que seu caso de uso seja compatível.
  2. Antes de atualizar seu código, faça verificações de desempenho e precisão nos seus modelos, especialmente se você estiver usando versões LiteRT anteriores que a versão 2.1, então você tem um valor de referência para comparar com o novo implementação.
  3. Se você migrou todo o código para usar a API Google 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 da criação do objeto new Interpreter no seu código. e modificar cada um 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 direta: é necessário registrar um listener para quando a chamada for concluída. Consulte o snippet de código na Etapa 3.
  5. Adicionar import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a qualquer origem usando a função 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 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 LiteRT independente e a API do Google Play Services ao mesmo tempo, use o LiteRT 2.9 (ou mais recente). LiteRT 2.8 e versões anteriores não são compatíveis com a versão da API Play Services.