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

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

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

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:

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 do Android thread da interface do usuário. Se você precisar gerenciar a execução de linhas de execução de forma mais precisa, pode adicionar uma chamada Tasks.await() para a criação do intérprete:

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

interpreter.run(inputBuffer, outputBuffer)

interpreter.run(inputBuffer, outputBuffer);

Aceleração de hardware

A LiteRT permite acelerar o desempenho do seu 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.

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

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 Interpreter

Para usar o delegado da GPU com as APIs de intérprete:

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

2. Ative a opção de delegado 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 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());
   

Como migrar da versão autônoma do LiteRT

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 suporte a esse caso de uso.
2. Antes de atualizar seu código, faça verificações de desempenho e precisão do seu modelos, especialmente se 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 Play Services para LiteRT, remova o ambiente de execução do LiteRT biblioteca (entradas com org.tensorflow:tensorflow-lite:*) do 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(). A O novo TfLite.Initialize é assíncrono, o que significa que, na maioria dos casos, ele não é um substituição simples: você deve registrar um listener para quando a chamada é 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 qualquer uma das chamadas resultantes para InterpreterApi.create() tiver apenas um argumento único, 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. com org.tensorflow.lite.InterpreterApi.

Se você quiser usar o LiteRT independente e a API Play Services lado a lado, é necessário usar o LiteRT 2.9 (ou posterior). LiteRT 2.8 e versões anteriores não são compatíveis com a versão da API Play Services.