Participe do Simpósio Women in ML em 7 de dezembro Inscreva-se agora

TensorFlow Lite nos serviços do Google Play

O TensorFlow Lite está disponível no tempo de execução do Google Play Services para todos os dispositivos Android que executam a versão atual do Play Services. Esse tempo de execução permite que você execute modelos de machine learning (ML) sem agrupar estaticamente as bibliotecas do TensorFlow Lite em seu aplicativo.

Com a API de serviços do Google Play, você pode reduzir o tamanho dos seus aplicativos e melhorar o desempenho da versão estável mais recente das bibliotecas. O TensorFlow Lite nos serviços do Google Play é a maneira recomendada de usar o TensorFlow Lite no Android.

Você pode começar a usar o tempo de execução do Play Services com o Quickstart , que fornece um guia passo a passo para implementar um aplicativo de exemplo. Se você já estiver usando o TensorFlow Lite autônomo em seu aplicativo, consulte a seção Migrando do TensorFlow Lite autônomo para atualizar um aplicativo existente para usar o tempo de execução do Play Services. Para obter mais informações sobre os serviços do Google Play, consulte o site dos serviços do Google Play .

Como usar o tempo de execução dos serviços do Google Play

O TensorFlow Lite no Google Play Services está disponível por meio da API de tarefas do TensorFlow Lite e da API de intérprete do TensorFlow Lite . A Biblioteca de Tarefas fornece interfaces de modelo prontas para uso otimizadas para tarefas comuns de aprendizado de máquina usando dados visuais, de áudio e de texto. A API do TensorFlow Lite Interpreter, fornecida pelo runtime e bibliotecas de suporte do TensorFlow, oferece uma interface de uso mais geral para criar e executar modelos de ML.

As seções a seguir fornecem instruções sobre como implementar as APIs Interpreter e Task Library nos serviços do Google Play. Embora seja possível que um aplicativo use as APIs do intérprete e as APIs da biblioteca de tarefas, a maioria dos aplicativos deve usar apenas um conjunto de APIs.

Usando as APIs da Biblioteca de Tarefas

A API de tarefas do TensorFlow Lite envolve a API do intérprete e fornece uma interface de programação de alto nível para tarefas comuns de aprendizado de máquina que usam dados visuais, de áudio e de texto. Você deve usar a API de tarefas se seu aplicativo exigir uma das tarefas com suporte .

1. Adicionar dependências do projeto

A dependência do seu projeto depende do seu caso de uso de aprendizado de máquina. As APIs de tarefas contêm as seguintes bibliotecas:

  • Biblioteca de visão: org.tensorflow:tensorflow-lite-task-vision-play-services
  • Biblioteca de áudio: org.tensorflow:tensorflow-lite-task-audio-play-services
  • Biblioteca de texto: org.tensorflow:tensorflow-lite-task-text-play-services

Adicione uma das dependências ao código do projeto do aplicativo para acessar a API do Play Services para TensorFlow Lite. Por exemplo, use o seguinte para implementar uma tarefa de visão:

dependencies {
...
    implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
...
}

2. Adicione a inicialização do TensorFlow Lite

Inicialize o componente TensorFlow Lite da API do Google Play Services antes de usar as APIs do TensorFlow Lite. O exemplo a seguir inicializa a biblioteca de visão:

Kotlin

init {
  TfLiteVision.initialize(context)
    }
  }

3. Execute inferências

Depois de inicializar o componente TensorFlow Lite, chame o método detect() para gerar inferências. O código exato dentro do método detect() varia dependendo da biblioteca e do caso de uso. O seguinte é para um caso de uso de detecção de objeto simples com a biblioteca TfLiteVision :

Kotlin

fun detect(...) {
  if (!TfLiteVision.isInitialized()) {
    Log.e(TAG, "detect: TfLiteVision is not initialized yet")
    return
  }

  if (objectDetector == null) {
    setupObjectDetector()
  }

  ...

}

Dependendo do formato dos dados, você também pode precisar pré-processar e converter seus dados no método detect() antes de gerar inferências. Por exemplo, os dados de imagem para um detector de objetos requerem o seguinte:

val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
val results = objectDetector?.detect(tensorImage)

Como usar as APIs do intérprete

As APIs do Interpreter oferecem mais controle e flexibilidade do que as APIs da Biblioteca de Tarefas. Você deve usar as APIs do intérprete se sua tarefa de aprendizado de máquina não for compatível com a biblioteca de tarefas ou se precisar de uma interface de uso mais geral para criar e executar modelos de ML.

1. Adicionar dependências do projeto

Adicione as seguintes dependências ao código do projeto do seu aplicativo para acessar a API do Play Services para 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. Adicione a inicialização do TensorFlow Lite

Inicialize o componente TensorFlow Lite da API do 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. Crie um intérprete e defina a opção de tempo de execução

Crie um interpretador usando InterpreterApi.create() e configure-o para usar o tempo 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()));
  });

Você deve usar a implementação acima porque evita bloquear o encadeamento da interface do usuário do Android. Se você precisar gerenciar a execução do encadeamento mais de perto, poderá adicionar 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. Faça 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çao do 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 tirar proveito desses processadores especializados usando drivers de hardware chamados delegados . Você pode usar os seguintes delegados de aceleração de hardware com o TensorFlow Lite no Google Play Services:

  • Delegado de GPU (recomendado) - esse delegado é fornecido por meio do Google Play Services e é carregado dinamicamente, assim como as versões do Play Services da API de tarefas e da API do intérprete.

  • Delegado NNAPI - Este delegado está disponível como uma dependência de biblioteca incluída em seu projeto de desenvolvimento Android e é empacotado em seu aplicativo.

Para obter mais informações sobre a aceleração de hardware com o TensorFlow Lite, consulte a página TensorFlow Lite Delegates .

Verificando a compatibilidade do dispositivo

Nem todos os dispositivos suportam aceleração de hardware de GPU com 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 este método para confirmar se um dispositivo é compatível com a GPU e use a CPU ou o delegado NNAPI como um substituto para quando a GPU não for compatível.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Depois de ter uma variável como useGpuTask , você pode usá-la para determinar se os dispositivos usam o delegado da GPU. Os exemplos a seguir mostram como isso pode ser feito com as APIs da Biblioteca de Tarefas e do Interpretador.

Com a API de tarefas

Kotlin

lateinit val optionsTask = useGpuTask.continueWith { task ->
  val baseOptionsBuilder = BaseOptions.builder()
  if (task.result) {
    baseOptionsBuilder.useGpu()
  }
 ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
}
    

Java

Task<ObjectDetectorOptions> optionsTask = useGpuTask.continueWith({ task ->
  BaseOptions baseOptionsBuilder = BaseOptions.builder();
  if (task.getResult()) {
    baseOptionsBuilder.useGpu();
  }
  return ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
});
    

Com a API do intérprete

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 biblioteca de tarefas

Para usar o delegado da GPU com as APIs de tarefas:

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

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
    
  2. Inicialize o delegado da GPU com setEnableGpuDelegateSupport . Por exemplo, você pode inicializar o delegado de GPU para TfLiteVision com o seguinte:

    Kotlin

        TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build())
        

    Java

        TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build());
        
  3. Habilite a opção de delegado de GPU com BaseOptions :

    Kotlin

        val baseOptions = BaseOptions.builder().useGpu().build()
        

    Java

        BaseOptions baseOptions = BaseOptions.builder().useGpu().build();
        
  4. Configure as opções usando .setBaseOptions . Por exemplo, você pode configurar a GPU no ObjectDetector com o seguinte:

    Kotlin

        val options =
            ObjectDetectorOptions.builder()
                .setBaseOptions(baseOptions)
                .setMaxResults(1)
                .build()
        

    Java

        ObjectDetectorOptions options =
            ObjectDetectorOptions.builder()
                .setBaseOptions(baseOptions)
                .setMaxResults(1)
                .build();
        

GPU com APIs de intérprete

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

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

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
    
  2. Habilite 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. Defina o delegado da GPU nas opções do interpretador para usar DelegateFactory chamando addDelegateFactory() dentro de 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 autônomo

Se você planeja migrar seu aplicativo do TensorFlow Lite autônomo para a API Play Services, consulte as seguintes orientações adicionais para atualizar o código do projeto do aplicativo:

  1. Revise 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 para seus modelos, principalmente se estiver usando versões do TensorFlow Lite anteriores à versão 2.1, para ter uma linha de base para comparar com a nova implementação.
  3. Se você migrou todo o seu código para usar a API do Play Services para TensorFlow Lite, remova as dependências existentes da biblioteca de tempo de execução do TensorFlow Lite (entradas com org.tensorflow: tensorflow-lite :* ) do arquivo build.gradle para que você pode reduzir o tamanho do seu aplicativo.
  4. Identifique todas as ocorrências da criação do new Interpreter em seu código e modifique-o para que ele use a chamada InterpreterApi.create(). Essa nova API é assíncrona, o que significa que, na maioria dos casos, não é uma substituição imediata e você deve registrar um ouvinte para quando a chamada for concluída. Consulte o trecho de código no código da Etapa 3 .
  5. Adicionar import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; para qualquer arquivo de origem usando as classes org.tensorflow.lite.Interpreter ou org.tensorflow.lite.InterpreterApi .
  6. Se qualquer uma das chamadas resultantes para InterpreterApi.create() tiver apenas um único argumento, anexe new InterpreterApi.Options() à lista de argumentos.
  7. Acrescente .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 TensorFlow Lite autônomo e a API do Play Services lado a lado, deverá usar o TensorFlow Lite 2.9 (ou posterior). O TensorFlow Lite 2.8 e versões anteriores não são compatíveis com a versão da API do Play Services.

Limitações

O TensorFlow Lite nos serviços do Google Play tem as seguintes limitações:

  • O suporte para delegados de aceleração de hardware é limitado aos delegados listados na seção Aceleração de hardware . Nenhum outro delegado de aceleração é suportado.
  • O acesso ao TensorFlow Lite por meio de APIs nativas não é compatível. Apenas as APIs Java do TensorFlow Lite estão disponíveis nos serviços do Google Play.
  • As APIs TensorFlow Lite experimentais ou obsoletas, incluindo operações personalizadas, não são compatíveis.

Suporte e feedback

Você pode fornecer feedback e obter suporte por meio do Issue Tracker do TensorFlow. Relate problemas e solicitações de suporte usando o modelo de problema do TensorFlow Lite no Google Play Services.

Termos de serviço

O uso do TensorFlow Lite nas APIs dos serviços do Google Play está sujeito aos Termos de Serviço das APIs do Google .

Privacidade e coleta de dados

Quando você usa o TensorFlow Lite nas APIs de serviços do Google Play, o processamento dos dados de entrada, como imagens, vídeo, texto, ocorre totalmente no dispositivo, e o TensorFlow Lite nas APIs de serviços do Google Play não envia esses dados para os servidores do Google. Como resultado, você pode usar nossas APIs para processar dados que não devem sair do dispositivo.

As APIs do TensorFlow Lite no Google Play Services podem entrar em contato com os servidores do Google de tempos em tempos para receber itens como correções de bugs, modelos atualizados e informações de compatibilidade do acelerador de hardware. As APIs do TensorFlow Lite no Google Play Services também enviam ao Google métricas sobre o desempenho e a utilização das APIs do seu aplicativo. O Google usa esses dados de métricas para medir o desempenho, depurar, manter e melhorar as APIs e detectar uso indevido ou abuso, conforme descrito em nossa Política de Privacidade .

Você é responsável por informar os usuários do seu aplicativo sobre o processamento do TensorFlow Lite pelo Google nos dados de métricas das APIs dos serviços do Google Play, conforme exigido pela lei aplicável.

Os dados que coletamos incluem o seguinte:

  • Informações do dispositivo (como fabricante, modelo, versão do SO e compilação) e aceleradores de hardware de ML disponíveis (GPU e DSP). Usado para diagnóstico e análise de uso.
  • Identificador de dispositivo usado para diagnóstico e análise de uso.
  • Informações do aplicativo (nome do pacote, versão do aplicativo). Usado para diagnóstico e análise de uso.
  • Configuração da API (como quais delegados estão sendo usados). Usado para diagnóstico e análise de uso.
  • Tipo de evento (como criação de intérprete, inferência). Usado para diagnóstico e análise de uso.
  • Códigos de erro. Usado para diagnóstico.
  • Métricas de desempenho. Usado para diagnóstico.

Próximos passos

Para obter mais informações sobre como implementar o aprendizado de máquina em seu aplicativo móvel com o TensorFlow Lite, consulte o Guia do desenvolvedor do TensorFlow Lite . Você pode encontrar modelos adicionais do TensorFlow Lite para classificação de imagens, detecção de objetos e outros aplicativos no TensorFlow Hub .