Reconhecer flores com o TensorFlow Lite no Android

1. Introdução

Observação:este codelab usa a biblioteca do TensorFlow Lite. Recomendamos que todo o novo código use as ferramentas da biblioteca Google AI Edge LiteRT.

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

O TensorFlow é um framework de machine learning de várias finalidades. É possível usar o TensorFlow para treinar modelos grandes em clusters na nuvem ou executar modelos localmente 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 uma versão mais recente

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

O que você vai aprender

• Como treinar seu próprio classificador de imagens personalizado usando o TensorFlow Lite Model Maker.
• Como usar o Android Studio para importar o modelo do TensorFlow Lite e integrar o modelo personalizado em 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 imagens do TensorFlow para identificar flores.

Licença: sem custo financeiro

2. Treinar um reconhecedor de flores usando o Colab

Antes de iniciar o treinamento de modelo, faça o download e instale o Android Studio 4.1 ou uma versão 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. baixou o modelo treinado (model.tflite) e
2. renomeou o arquivo FlowerModel.tflite

antes de continuar.

Alguns navegadores bloqueiam os downloads:

Talvez seja necessário dar permissão ao Colab para baixar os arquivos:

3. Configurar o diretório de trabalho

Clonar o repositório Git

O comando a seguir vai clonar o repositório do Git com 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 esqueleto do Android

Instalar o Android Studio 4.1 ou uma versão mais recente

Se você ainda não o tem, 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 . Depois que ele for carregado, selecione "Abrir um projeto atual" nesta janela 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 você não souber o que fazer, consulte o módulo finish para receber uma dica.

3. Na primeira vez que você abrir o projeto, vai aparecer uma janela pop-up "Sincronização do Gradle" perguntando sobre o uso do wrapper do Gradle. Clique em "OK".

4. Ative o modo de desenvolvedor e a depuração USB no smartphone, se ainda não tiver feito isso. Essa é uma configuração única. Siga estas instruções.
5. Quando o projeto e o smartphone estiverem prontos, execute-o 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. A seguinte tela vai aparecer no smartphone com números aleatórios no lugar dos resultados reais.

5. Adicionar o TensorFlow Lite ao app Android

1. Selecione o módulo start no explorador de projetos à esquerda:

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

3. Selecione o local do modelo em que você baixou o FlowerModel.tflite treinado personalizado anteriormente.

A ferramenta vai 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 Android.

4. Clique em Finish.
5. Você vai encontrar o seguinte no final. O FlowerModel.tflite é importado com sucesso e mostra as informações de alto nível sobre o modelo, incluindo entrada / saída e um exemplo de código para você começar.

6. Opcional: conferir 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 usar no seu Projeto do Android para lembrar de trabalhos futuros. Você pode adicionar itens a fazer usando comentários de código e digitando a palavra-chave TODO. Para acessar a lista de TODOs, você pode:

1. Uma ótima maneira de ver o que vamos fazer é conferir a lista de tarefas. Para fazer isso, selecione na barra de menus superior View > Tool Windows > TODO

2. Por padrão, ele lista todos os TODOs em todos os módulos, o que pode ser um pouco confuso. Para classificar apenas as tarefas pendentes de início, clique no botão "Agrupar por" ao lado do painel de tarefas pendentes e escolha Modules.

3. Abra 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. Dentro do método de análise do CameraX Analyzer, precisamos converter a entrada de 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.

• Ou seja, se a entrada for um arquivo em vez de ImageProxy, você poderá levá-lo diretamente ao método fromBitmap como um objeto Bitmap.
• Se você quiser saber como ImageProxy é convertido em Bitmap, confira o método toBitmap e o YuvToRgbConverter. Esperamos que a necessidade desses métodos seja temporária enquanto a equipe trabalha para oferecer suporte ao ImageProxy para 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:

• Ordene os resultados por probabilidade em ordem decrescente no atributo score, começando pela maior probabilidade.
• Use os k principais resultados definidos pela constante MAX_RESULT_DISPLAY. Você pode variar o valor dessa variável para ter 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 via 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. Marque como comentário ou exclua as seguintes linhas, 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 pressione o botão de execução na barra de ferramentas:

9. A seguinte tela vai aparecer no seu smartphone com números aleatórios no lugar dos resultados reais:

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

O TensorFlow Lite é compatível com 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 usando um mecanismo de delegação, e é bem fácil de usar.

1. Abra build.gradle no módulo start ou clique em "TODO 5" na lista de tarefas 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, quando você fizer 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 ao arquivo MainActivity.kt ou clique em TODO 6 na lista de tarefas. Substitua a inicialização simples do flowerModel pelo seguinte: receba uma instância da lista de compatibilidade de GPU e inicialize a GPU dependendo se ela é uma das GPUs compatíveis listadas. Caso contrário, inicie quatro linhas de execução da 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 sua importação.

3. Mude o inicializador do modelo para usar isso 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 pressione o botão de execução na barra de ferramentas:

Em um dispositivo móvel de nível médio/alto, a GPU é muito mais rápida do que a CPU. Dispositivos de baixa capacidade tendem a ter GPUs mais lentas, então a aceleração que você vê vai variar.

9. Próximos passos

Confira alguns links para mais informações:

• Teste outros modelos do TFLite compatíveis com a vinculação de modelos de ML em tfhub.dev.
• Saiba mais sobre o TFLite na documentação em tensorflow.org e no repositório de código (links em inglês).
• Tente usar outros modelos pré-treinados do TFLite, incluindo um detector de hotwords de fala e uma versão de resposta inteligente no dispositivo.
• Saiba mais sobre o TensorFlow em geral com a documentação de primeiros passos.