Reconhecer flores com o TensorFlow Lite no Android

1. Introdução

Observação: este codelab requer um dispositivo físico para testar

O TensorFlow é um framework de machine learning para várias finalidades. O TensorFlow pode ser usado de diversas formas, desde o treinamento de modelos enormes em clusters na nuvem até a execução local de modelos em um sistema incorporado, como seu smartphone.

Este codelab usa o TensorFlow Lite para executar um modelo de reconhecimento de imagem em um dispositivo Android.

Instalar o Android Studio 4.1 ou mais recente

Se você ainda não tiver feito isso, faça o download e instale o Android Studio 4.1 ou uma versão mais recente enquanto treina seu modelo do TensorFlow Lite.

O que você vai aprender

• Como treinar seu próprio classificador de imagens personalizadas usando o TensorFlow Lite Model Maker.
• Como usar o Android Studio para importar o modelo do TensorFlow Lite e integrar o modelo personalizado a um app Android usando o CameraX.
• Como usar a GPU no smartphone para acelerar o modelo.

O que você criará

Um app de câmera simples que executa um programa de reconhecimento de imagem do TensorFlow para identificar flores.

Licença: sem custo financeiro

2. Treinar um reconhecedor de flores usando o Colab

Antes de começar o treinamento de modelo, faça o download e instale o Android Studio 4.1 ou mais recente.

Abra o Colab, que mostra como treinar um classificador com o Keras para reconhecer flores usando o aprendizado por transferência do TensorFlow Lite.

Não se esqueça de:

1. fez o download do modelo treinado (model.tflite)
2. renomeou o arquivo FlowerModel.tflite

antes de continuar.

Alguns navegadores bloqueiam os downloads:

Talvez seja necessário permitir que o Colab faça o download dos arquivos:

3. Configurar o diretório de trabalho

Clonar o repositório Git

O comando a seguir vai clonar o repositório Git que contém os arquivos necessários para este codelab:

git clone https://github.com/hoitab/TFLClassify.git

Em seguida, acesse o diretório em que você acabou de clonar o repositório. É aqui que você vai trabalhar pelo restante deste codelab:

cd TFLClassify

4. Configurar o app Android Structure

Instalar o Android Studio 4.1 ou mais recente

Se você ainda não tiver feito isso, instale o Android Studio 4.1 ou uma versão mais recente.

Abrir o projeto com o Android Studio

Abra um projeto com o Android Studio seguindo estas etapas:

1. Abra o Android Studio . Após o carregamento, selecione "Open an Existing project" neste pop-up:

2. No seletor de arquivos, escolha TFLClassify/build.gradle no diretório de trabalho.

O projeto contém dois módulos, start e finish. Se tiver dificuldades, consulte o módulo finish para ver uma dica.

3. Você vai receber uma mensagem "Gradle Sync" pop-up, na primeira vez que você abrir o projeto, perguntando sobre o uso do wrapper do Gradle. Clique em "OK".

4. Ative o modelo de desenvolvedor e a depuração USB em seu telefone se ainda não tiver feito isso. Essa configuração é feita apenas uma vez. Siga estas instruções.
5. Quando o projeto e o smartphone estiverem prontos, execute em um dispositivo real selecionando TFL_Classify.start e pressionando o botão de execução na barra de ferramentas:

6. Agora permita que a demonstração do Tensorflow acesse sua câmera:

7. Você verá a tela a seguir no seu smartphone com números aleatórios no lugar de onde os resultados reais serão exibidos.

5. Adicionar o TensorFlow Lite ao app Android

1. Selecione o módulo start no explorador de projetos no lado esquerdo:

2. Clique com o botão direito do mouse no módulo start ou em File e depois em New > Other > TensorFlow Lite Model

3. Selecione o local do modelo em que você já fez o download do FlowerModel.tflite treinado personalizado.

As ferramentas vão configurar a dependência do módulo em seu nome com a vinculação de modelos de ML e todas as dependências inseridas automaticamente no arquivo build.gradle do módulo do Android.

4. Clique em Finish.
5. Você verá o seguinte no final. O FlowerModel.tflite foi importado e mostra informações de alto nível sobre o modelo, incluindo entrada / saída, bem como alguns exemplos de código para você começar.

6. Opcional: como verificar toda a lista de tarefas

A lista de tarefas facilita a navegação até o local exato em que você precisa atualizar o codelab. Você também pode usá-lo em seu projeto Android para se lembrar de trabalhos futuros. Para adicionar itens de tarefas, use os comentários de código e digite a palavra-chave TODO. Para acessar a lista de tarefas, você pode:

1. Uma ótima maneira de saber o que vamos fazer é dar uma olhada na lista de tarefas. Para fazer isso, selecione View na barra de menus superior > Tool Windows > TODO

2. Por padrão, ele lista todos os TODOs em todos os módulos, o que o torna um pouco confuso. Podemos classificar apenas os TODOs iniciais clicando no botão group by na lateral do painel TODO e escolha Modules

3. Expanda todos os itens nos módulos iniciais:

7. Executar o modelo personalizado com o TensorFlow Lite

1. Clique em TODO 1 na lista de tarefas ou abra o arquivo MainActivity.kt e localize TODO 1. Inicialize o modelo adicionando esta linha:

private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {

  ...
  // TODO 1: Add class variable TensorFlow Lite Model
  private val flowerModel = FlowerModel.newInstance(ctx)

  ...
}

2. No método de análise do analisador CameraX, precisamos converter a entrada da câmera ImageProxy em um Bitmap e criar um objeto TensorImage para o processo de inferência.

As ferramentas atuais exigem que a entrada de imagem esteja no formato Bitmap.

• Isso significa que, se a entrada for um arquivo em vez de ImageProxy, você poderá alimentá-la diretamente ao método fromBitmap como um objeto Bitmap.
• Se você quiser saber como o ImageProxy é convertido em Bitmap, confira o método toBitmap e o YuvToRgbConverter. Esperamos que essas necessidades sejam temporárias enquanto a equipe trabalha para oferecer suporte à ImageProxy para o TensorImage.

override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 2: Convert Image to Bitmap then to TensorImage
  val tfImage = TensorImage.fromBitmap(toBitmap(imageProxy))
  ...
}

3. Processe a imagem e execute as seguintes operações no resultado:

• Classifique os resultados de maneira decrescente por probabilidade no atributo score, com a maior probabilidade primeiro.
• Pegue os resultados Top-K, conforme definido pela constante MAX_RESULT_DISPLAY. Você tem a opção de variar o valor dessa variável para obter mais ou menos resultados.

override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 3: Process the image using the trained model, sort and pick out the top results
  val outputs = flowerModel.process(tfImage)
      .probabilityAsCategoryList.apply {
          sortByDescending { it.score } // Sort with highest confidence first
      }.take(MAX_RESULT_DISPLAY) // take the top results

  ...
}

4. Converta os resultados classificados e filtrados em objetos de dados Recognition prontos para serem consumidos por RecyclerView usando a Vinculação de dados:

override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 4: Converting the top probability items into a list of recognitions
  for (output in outputs) {
      items.add(Recognition(output.label, output.score))
  }
  ...
}

5. Comente ou exclua as linhas abaixo, que ajudam a gerar os resultados falsos que vimos antes:

// START - Placeholder code at the start of the codelab. Comment this block of code out.
for (i in 0..MAX_RESULT_DISPLAY-1){
    items.add(Recognition("Fake label $i", Random.nextFloat()))
}
// END - Placeholder code at the start of the codelab. Comment this block of code out.

8. Execute o app em um dispositivo real selecionando TFL_Classify.start e pressionando o botão de execução na barra de ferramentas:

9. Você verá a seguinte tela no seu smartphone com números aleatórios no lugar de onde os resultados reais serão exibidos:

8. Opcional: acelerar a inferência com o delegado da GPU

O TensorFlow Lite oferece suporte a vários aceleradores de hardware para acelerar a inferência no seu dispositivo móvel. A GPU é um dos aceleradores que o TensorFlow Lite pode aproveitar com um mecanismo de delegação e é bastante fácil de usar.

1. Abra build.gradle no módulo start ou clique em "TODO 5" na lista e adicione a seguinte dependência:

// TODO 5: Optional GPU Delegates    
implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'

Observação: estamos adicionando essa importação manualmente neste codelab, mas, ao fazer isso no seu projeto, basta marcar a segunda caixa na tela de importação para adicionar a dependência de aceleração de GPU:

2. Volte para o arquivo MainActivity.kt ou clique em "TODO" na lista. Substitua a iniciação simples de flowerModel pelo seguinte: acesse uma instância da lista de compatibilidade de GPUs e inicialize a GPU dependendo se ela é uma das GPUs compatíveis listadas. Caso contrário, inicie quatro linhas de execução de CPU para executar o modelo:

private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {
  ...

  // TODO 1: Add class variable TensorFlow Lite Model
  // Initializing the flowerModel by lazy so that it runs in the same thread when the process
  // method is called.
  private val flowerModel: FlowerModel by lazy{

    // TODO 6. Optional GPU acceleration
    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice){
        Log.d(TAG, "This device is GPU Compatible ")
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        Log.d(TAG, "This device is GPU Incompatible ")
        Model.Options.Builder().setNumThreads(4).build()
    }

  ...
}

Observação: há vários objetos Model. Escolha o objeto org.tensorflow.lite.support.model.Model na importação.

3. Mude o inicializador do modelo para usá-lo adicionando options à entrada do método:

private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {

  private val flowerModel: FlowerModel by lazy{

    ...

    // Initialize the Flower Model
    FlowerModel.newInstance(ctx, options)
  }
}

10. Execute o app em um dispositivo real selecionando TFL_Classify.start e pressionando o botão de execução na barra de ferramentas:

Em um dispositivo móvel de médio/alto nível, a GPU é muito mais rápida do que a CPU. Dispositivos mais simples costumam ter GPUs mais lentas, então a velocidade pode variar.

9. Próximos passos

Aqui estão alguns links para mais informações:

• Teste outros modelos do TFLite compatíveis com a vinculação de modelos de ML do tfhub.dev.
• Saiba mais sobre o TFLite nos documentos em tensorflow.org e no repositório de códigos (links em inglês).
• Teste alguns outros modelos pré-treinados do TFLite, incluindo um detector de hotword de fala e uma versão de resposta inteligente no dispositivo.
• Para saber mais sobre o TensorFlow em geral, consulte nossos documentos de primeiros passos.