Integrar um modelo personalizado ao app

1. Antes de começar

No primeiro codelab desta série, você criou um app muito simples que usou a rotulagem de imagens para analisar o conteúdo de uma imagem. Você passou uma foto de uma margarida, e isso retornava a imagem de coisas como pétalas ou do céu. Depois, no segundo codelab, você migrou para o Python para treinar um novo modelo personalizado que reconhece cinco tipos diferentes de flor.

Neste codelab, você atualizará o app do primeiro laboratório com o modelo do segundo.

Para receber o código-fonte completo deste codelab, clone este repositório. Você verá os subdiretórios para Android e iOS. O código do codelab anterior está disponível como ImageClassifierStep1 se você quiser acompanhar o codelab. O código finalizado deste codelab está disponível como ImageClassifierStep2.

Prerequisites

  • Você deve ter concluído os dois primeiros codelabs neste programa de aprendizado

O que você criará e aprenderá

  • Integrar um modelo personalizado, treinado no laboratório anterior, a um app Android ou iOS

Pré-requisitos

  • Android Studio, disponível em developer.android.com/studio para a parte Android do laboratório
  • Xcode, disponível na Apple App Store, para a parte do iOS do laboratório

2. Instalar o app inicial

Primeiro, você precisará do app do codelab "Criar seu primeiro app de visão computacional" no Android ou iOS. Se você tiver concluído o laboratório, o nome dela será ImageImageifierStep1. Se você não quiser passar pelo laboratório, clone a versão concluída do repositório.

Abra-o no Android Studio, faça as atualizações necessárias e, quando estiver pronto, execute o app para conferir se ele funciona. Você verá algo como:

f3703d45d1332d1d.png

É um app bastante primitivo, mas mostra funcionalidades muito avançadas com apenas um pouco de código. No entanto, se quiser que essa flor seja reconhecida como uma margarida, e não apenas como uma flor, você precisará atualizar o app para usar o modelo personalizado do codelab "Criar um modelo personalizado" para o classificador de imagens.

3. Atualizar build.gradle para usar modelos personalizados do Kit de ML

  1. Com o Android Studio, localize o arquivo build.gradle no nível do app. A maneira mais fácil de fazer isso é no explorador de projetos. Verifique se a opção Android está selecionada na parte superior. Você verá uma pasta para Gradle Scripts na parte inferior.
  2. Abra o módulo referente ao Module, com o nome do app seguido por ".app", conforme mostrado aqui: (Module: ImageClassifierStep1.app):

8fe1d04b40610047.png

  1. Na parte inferior do arquivo, localize a configuração dependencies. Nela, você verá esta linha:
implementation 'com.google.mlkit:image-labeling:17.0.1'

O número da versão pode ser diferente. O número da versão mais recente está no site do Kit de ML em: https://developers.google.com/ml-kit/vision/image-labeling/android

  1. Substitua-o pela referência da biblioteca de rotulagem de imagens personalizada. O número da versão pode ser encontrado em: https://developers.google.com/ml-kit/vision/image-labeling/custom-models/android
implementation 'com.google.mlkit:image-labeling-custom:16.3.1'
  1. Além disso, você adicionará um modelo do .tflite que criou no laboratório anterior. Não é recomendável compactar esse modelo quando o Android Studio compila o app. Portanto, use essa configuração na seção Android do mesmo arquivo build.gradle:
aaptOptions{
    noCompress "tflite"
}

Confira se ele não está em outra configuração. Ele precisa ser aninhado diretamente na tag android. Veja um exemplo:

62d546bff11d2a50.png.

4. Adicionar o modelo TFLite

No codelab anterior, você criou seu modelo personalizado e fez o download dele como model.tflite.

No projeto, localize a pasta assets que contém o flower1.jpg. Copie o modelo para essa pasta da seguinte maneira:

  1. Clique com o botão direito na pasta Assets no Android Studio. No menu exibido, selecione Reveal in Finder. ("Mostrar no Explorador" no Windows e "Mostrar no Files" no Linux)

db30b47e419a326b.png

  1. Você será direcionado para o diretório do sistema de arquivos. Copie o arquivo model.tflite para esse diretório junto com flower1.jpg..

36de0c51bec1c19e.png

O Android Studio será atualizado para mostrar os dois arquivos na pasta de recursos:

e9f4e9f394d9b357.png

Agora está tudo pronto para atualizar seu código.

5. Atualizar seu código para o modelo personalizado

A primeira etapa será adicionar código para carregar o modelo personalizado.

  1. No arquivo MainActivity, adicione o seguinte ao onCreate, logo abaixo da linha setContentView(R.layout.activity_main).

Um LocalModel será criado a partir do recurso model.tflite. Se o Android Studio reclamar deixar "LocalModel" vermelho, pressione ALT + Enter para importar a biblioteca. Ele deve adicionar uma importação a com.google.mlkit.common.model.LocalModel para você.

val localModel = LocalModel.Builder()
        .setAssetFilePath("model.tflite")
        .build()

Anteriormente, no gerenciador btn.setOnClickListener, você estava usando o modelo padrão. Ela foi configurada com este código:

val labeler = ImageLabeling.getClient(ImageLabelerOptions.DEFAULT_OPTIONS)

Substitua-o para usar o modelo personalizado.

  1. Configure um objeto de opções personalizadas:
val options = CustomImageLabelerOptions.Builder(localModel)
        .setConfidenceThreshold(0.7f)
        .setMaxResultCount(5)
        .build()

Isso substitui as opções padrão por um conjunto personalizado. O limite de confiança define uma qualidade para o retorno das previsões. Analisando a amostra na parte superior deste codelab, em que a imagem era uma margarida, você tinha quatro previsões, cada uma com um valor ao lado delas, como "Sky" sendo 0,7632.

É possível filtrar resultados de qualidade inferior usando um limite de confiança alto. Definir esse valor como 0.9, por exemplo, não retornaria nenhum rótulo com prioridade menor que essa. A setMaxResultCount() é útil em modelos com muitas classes, mas, como esse modelo só tem 5, você o definirá apenas como 5.

Agora que você tem opções para o rotulador, é possível alterar a instanciação do rotulador para:

val labeler = ImageLabeling.getClient(options)

O restante do código será executado sem modificação. Experimente!

dd40c36c4edbb33.png

Veja que agora essa flor foi identificada como uma margarida com probabilidade de 0,959.

Digamos que você adicionou uma segunda imagem de flores e a executou novamente com isso:

8556a5fbea487842.png

Ele é identificado como uma rosa.

Você pode se perguntar por que ela diz rosas em vez de apenas "rosas". Isso ocorre porque, no conjunto de dados, os rótulos são fornecidos pelos nomes das pastas e, infelizmente, esses nomes são um pouco inconsistentes, às vezes usando singular (como "margarida") e, às vezes, usando plural (como "rosas"). Não confunda isso com o modelo que tenta contar os itens na imagem. É muito mais primitivo do que isso e só consegue identificar os tipos de flores.

6. Instalar o app iOS Start

  1. Primeiro, você precisará do app do primeiro codelab. Se você tiver concluído o laboratório, o nome dela será ImageImageifierStep1. Se você não quiser passar pelo laboratório, poderá clonar a versão concluída do repositório. Os pods e o .xcworkspace não estão presentes no repositório. Portanto, antes de avançar para a próxima etapa, execute "pod install" no mesmo diretório do .xcproject.
  2. Abra ImageClassifierStep1.xcworkspace no Xcode. Você precisa usar o .xcworkspace, e não o .xcproject, porque você incluiu um pacote de ML usando pods e o espaço de trabalho os carregará.

No restante deste laboratório, vou executar o app no simulador do iPhone, que precisa ser compatível com os destinos de compilação do codelab. Se você quiser usar seu próprio dispositivo, talvez seja necessário alterar o destino de build nas configurações do projeto para corresponder à versão do iOS.

Execute-o para ver algo parecido com isto:

9e151ed18f99fb98.png

Observe as classificações muito genéricas: pétala, flor, céu. O modelo que você criou no codelab anterior foi treinado para detectar cinco variedades de flores, incluindo esta: uma margarida.

No restante deste codelab, você verá o que será necessário para fazer upgrade do seu app com o modelo personalizado.

7. Usar pods de rotuladores de imagens do kit de ML personalizados

O primeiro app usou um arquivo pod para acessar as bibliotecas e o modelo básicos do Image Kit de ML. Será necessário atualizá-lo para usar as bibliotecas de rotulagem de imagens personalizadas.

  1. Encontre o arquivo podfile no diretório do projeto. Abra-o e você verá algo como:
platform :ios, '10.0'

target 'ImageClassifierStep1' do
        pod 'GoogleMLKit/ImageLabeling'
end
  1. Mude a declaração do pod de ImageLabeling para ImageLabelingCustom desta forma:
platform :ios, '10.0'

target 'ImageClassifierStep1' do
        pod 'GoogleMLKit/ImageLabelingCustom'
end
  1. Quando terminar, use o terminal para navegar até o diretório que contém o podfile (e o .xcworkspace) e execute pod install.

bb5d78eb7c7ab975.png

Após alguns instantes, as bibliotecas MLKitImageLabeling serão removidas e as bibliotecas personalizadas serão adicionadas. Agora você pode abrir seu .xcworkspace para editar o código.

8. Adicionar o modelo TFLite ao Xcode

No codelab anterior, você criou um modelo personalizado e fez o download dele como model.tflite. Se você não tiver esse recurso em mãos, volte e execute este codelab ou siga o código de colab aqui. Se você não tiver acesso ao Google Colab, o notebook estará disponível neste link.

  1. Com o espaço de trabalho aberto no Xcode, arraste o model.tflite para o projeto. Ele estará na mesma pasta dos outros arquivos, como ViewController.swift ou Main.storyboard.
  2. Uma caixa de diálogo será exibida com opções para adicionar o arquivo. Verifique se a opção Adicionar aos destinos está selecionada para que o modelo não seja empacotado com o app quando for implantado em um dispositivo.

A entrada "Add to Targets" terá ImageClassifierStep1 se você tiver iniciado por esse laboratório e continue por este laboratório passo a passo ou ImageClassifierStep2 (como mostrado) se você tiver pulado para o código finalizado.

5b6a7f40c73f0f1f.png

Isso garantirá que você possa carregar o modelo. Você aprenderá a fazer isso na próxima etapa.

9. Atualizar seu código para o modelo personalizado

  1. Abra o arquivo ViewController.swift. Você verá um erro em "import MLKitImageLabeling" na parte superior do arquivo. Isso ocorreu porque você removeu as bibliotecas genéricas de rotulagem de imagens ao atualizar o arquivo do pod. Você pode excluir essa linha e fazer as seguintes atualizações:
import MLKitVision
import MLKit
import MLKitImageLabelingCommon
import MLKitImageLabelingCustom

Pode ser fácil fazer isso e achar que eles estão repetindo o mesmo código. Mas é "Comum" e "Personalizado" no final.

  1. Em seguida, você carregará o modelo personalizado adicionado na etapa anterior. Encontre a função getLabels(). Abaixo da linha visionImage.orientation = image.imageOrientation, adicione estas linhas:
// Add this code to use a custom model
let localModelFilePath = Bundle.main.path(forResource: "model", ofType: "tflite")
let localModel = LocalModel(path: localModelFilePath!)
  1. Encontre o código para especificar as opções do ImageLabeler genérico. Provavelmente, isso está gerando um erro porque essas bibliotecas foram removidas:
let options = ImageLabelerOptions()

Substitua-o por este código para usar um CustomImageLabelerOptions e especificar o modelo local:

let options = CustomImageLabelerOptions(localModel: localModel)

...e é só isso! Tente executar o app agora. Ao tentar classificar a imagem, ela deve ser mais precisa e informar que você está olhando para uma margarida com alta probabilidade.

238cd21748a97cf4.png

Digamos que você adicionou uma segunda imagem de flores e a executou novamente com isso:

75f3970a6b509bfe.png

O app detectou que essa imagem corresponde ao rótulo "rosas".

10. Parabéns!

Agora, você sabe criar um app que usa um modelo genérico para reconhecer o conteúdo de uma imagem, criar seu próprio modelo de ML para reconhecer itens específicos, como flores, e atualizar o app para usar o modelo personalizado.

O app resultante é, obviamente, muito limitado porque se baseava em recursos de imagem agrupados. No entanto, a parte do ML está funcionando bem. Você pode, por exemplo, usar a AndroidX Camera para capturar frames de um feed publicado e classificá-las para ver quais flores o smartphone reconhece.

As possibilidades são infinitas. E, se você tem seus próprios dados para algo diferente das flores, tem as bases do que é necessário para criar um app que as reconheça usando a visão computacional. Esses são apenas os primeiros passos em um mundo muito mais amplo e esperamos que você tenha gostado de trabalhar com eles.