Integrar um modelo personalizado ao aplicativo

1. Antes de começar

No primeiro codelab desta série, você criou um app muito simples que usava a rotulagem de imagens para analisar o conteúdo de uma imagem. Você deu a ela a imagem de uma margarida e ela devolveu que ela viu coisas como uma pétala ou o céu. Depois, no segundo codelab, você mudou para Python para treinar um modelo novo e personalizado que reconhece cinco tipos diferentes de flores.

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

Clone este repositório para ver o código-fonte completo deste codelab. Você verá subdiretórios para Android e iOS. Se você quiser acompanhar o codelab anterior, ele está disponível como ImageClassifierStep1. O código final deste codelab está disponível como ImageClassifierStep2.

Pule para a etapa 6 para iOS.

Pré-requisitos

• É necessário ter concluído os dois primeiros codelabs deste programa de aprendizado.

O que você vai criar e aprender

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

O que é necessário

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

2. Baixar o app inicial

Primeiro, você vai precisar do app do codelab "Criar seu primeiro app de visão computacional no Android ou iOS". Se você já realizou o laboratório, ele se chamará ImageClassifierStep1. Se não quiser fazer o laboratório, você pode clonar a versão final do repositório

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

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

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

1. No Android Studio, localize o arquivo build.gradle do app. A maneira mais fácil de fazer isso é pelo explorador de projetos. Verifique se Android está selecionado na parte superior. Você verá uma pasta para Gradle Scripts na parte inferior.
2. Abra o arquivo do Module, com o nome do app seguido por ".app". conforme mostrado aqui – (Module: ImageClassifierStep1.app):

3. Na parte de baixo do arquivo, encontre 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. Sempre encontre o número da versão mais recente no site do Kit de ML em: https://developers.google.com/ml-kit/vision/image-labeling/android

4. Substitua pela referência da biblioteca de rotulagem de imagens personalizadas. 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'

5. Além disso, você vai adicionar um modelo .tflite criado no laboratório anterior. Esse modelo não será compactado quando o Android Studio compilar seu app. Portanto, use essa configuração na seção Android do mesmo arquivo build.gradle:

aaptOptions{
    noCompress "tflite"
}

Verifique se ele não está em nenhuma outra configuração. Ela precisa ser aninhada diretamente abaixo da tag android. Veja um exemplo:

4. Adicionar o modelo do TFLite

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

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

1. Clique com o botão direito do mouse na pasta Assets no Android Studio. No menu que é aberto, selecione Revelar no Finder. ("Mostrar no Explorador" no Windows e "Mostrar no Arquivos" no Linux.)

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

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

Agora você já pode 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).

Isso vai usar um LocalModel para criar a partir do recurso model.tflite. Se o Android Studio reclamar virando "LocalModel" vermelho, pressione ALT + Enter para importar a biblioteca. Isso vai 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. Ele foi configurado com este código:

val labeler = ImageLabeling.getClient(ImageLabelerOptions.DEFAULT_OPTIONS)

Você o substituirá para usar o modelo personalizado.

2. 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 os limites para o retorno da qualidade das previsões. O exemplo no início deste codelab, em que a imagem era uma margarida, mostra que há quatro previsões, cada uma com um valor ao lado, como "Sky". sendo 0,7632.

Você poderia filtrar de forma eficiente os resultados de qualidade inferior usando um limite de confiança alto. Definir como 0,9, por exemplo, não retornaria nenhum rótulo com prioridade menor que essa. O setMaxResultCount() é útil em modelos com muitas classes, mas como esse modelo tem apenas cinco, deixe-o como 5.

Agora que você tem opções para o rotulador, pode mudar a instanciação dele para:

val labeler = ImageLabeling.getClient(options)

O restante do código será executado sem modificações. Experimente!

Aqui você pode ver que esta flor foi identificada como uma margarida com probabilidade de 0,959!

Digamos que você adicionou uma segunda imagem de flor e executou novamente com ela:

Ele a identifica como uma rosa.

Você pode se perguntar por que aparece rosas em vez de apenas "rosa". 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 "daisy") e outras, plural (como "rosas"). Não confunda isso com o modelo tentando contar os itens na imagem. Ele é muito mais primitivo do que isso e só consegue identificar os tipos de flores.

6. Baixar o app iOS Start

1. Para começar, você precisa do app do primeiro codelab. Se você já realizou o laboratório, ele se chamará ImageClassifierStep1. Caso não queira fazer o laboratório, clone a versão final do repositório. Como os pods e o .xcworkspace não estão presentes no repositório, execute "pod install" antes de passar para a próxima etapa. do mesmo diretório que o .xcproject.
2. Abra ImageClassifierStep1.xcworkspace no Xcode. Use o .xcworkspace e não o .xcproject porque você agrupou o kit de ML usando pods, e o espaço de trabalho vai carregá-los.

Durante este laboratório, vamos executar o app no simulador do iPhone, que é compatível com os destinos de build do codelab. Se quiser usar seu próprio dispositivo, talvez seja necessário mudar o destino do build nas configurações do projeto para corresponder à versão do iOS.

Execute-o e você verá algo assim:

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 é necessário para fazer upgrade do app com o modelo personalizado.

7. Usar pods personalizados do rotulador de imagens do Kit de ML

O primeiro app usou um arquivo pod para conseguir as bibliotecas e o modelo base do rotulador de imagens do kit de ML. Você precisa fazer a atualização para usar as bibliotecas de rotulagem de imagens personalizadas.

1. Encontre o arquivo chamado podfile no diretório do projeto. Ao abri-lo, você verá algo parecido com:

platform :ios, '10.0'

target 'ImageClassifierStep1' do
        pod 'GoogleMLKit/ImageLabeling'
end

2. Mude a declaração do pod de ImageLabeling para ImageLabelingCustom, da seguinte forma:

platform :ios, '10.0'

target 'ImageClassifierStep1' do
        pod 'GoogleMLKit/ImageLabelingCustom'
end

3. Quando terminar, use o terminal para navegar até o diretório que contém o podfile (e o .xcworkspace) e execute pod install.

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

8. Adicionar o modelo do TFLite ao Xcode

No codelab anterior, você criou um modelo personalizado e fez o download dele como model.tflite. Se não tiver, volte e execute o codelab ou leia o código do Colab neste link. Se você não tiver acesso ao Google Colab, o notebook está disponível neste link.

1. Com o espaço de trabalho aberto no Xcode, arraste o model.tflite para seu projeto. Ele precisa estar na mesma pasta que os outros arquivos, como ViewController.swift ou Main.storyboard.
2. Será exibida uma caixa de diálogo com opções para adicionar o arquivo. Certifique-se de que Add to Targets esteja selecionado. Caso contrário, o modelo não será empacotado com o app quando for implantado em um dispositivo.

A opção "Adicionar a destinos" entrada terá ImageClassifierStep1 se você tiver começado a partir disso e estiver seguindo este laboratório passo a passo, ou ImageClassifierStep2 (como mostrado) se você tiver pulado para o código finalizado.

Isso vai garantir que você carregue o modelo. Você verá como fazer isso na próxima etapa.

9. Atualizar o código do modelo personalizado

1. Abra o arquivo ViewController.swift. Talvez você veja um erro na guia "import MLKitImageLabeling" na parte superior do arquivo. Isso ocorre porque você removeu as bibliotecas genéricas de rotulagem de imagens ao atualizar o arquivo pod. Você pode excluir essa linha e atualizar com o seguinte:

import MLKitVision
import MLKit
import MLKitImageLabelingCommon
import MLKitImageLabelingCustom

Pode ser fácil ler essas informações rapidamente e pensar que estão repetindo o mesmo código. Mas é "Comum" e "Personalizado" no final.

2. Em seguida, você vai carregar o modelo personalizado que adicionou 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!)

3. Encontre o código para especificar as opções do ImageLabeler genérico. Você provavelmente está recebendo um erro, já que essas bibliotecas foram removidas:

let options = ImageLabelerOptions()

Substitua-o por este código para usar um CustomImageLabelerOptions, que especifica o modelo local:

let options = CustomImageLabelerOptions(localModel: localModel)

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

Digamos que você adicionou uma segunda imagem de flor e executou novamente com ela:

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

10. Parabéns!

Você começou a criar um app que usa um modelo genérico para reconhecer o conteúdo de uma imagem, depois criou seu próprio modelo de ML para reconhecer itens específicos, como flores, e depois atualizou o app para usar um modelo personalizado.

O aplicativo resultante é, obviamente, muito limitado, porque dependia de recursos de imagem agrupada. No entanto, a parte do ML está funcionando bem. Você pode, por exemplo, usar a câmera do AndroidX para extrair frames de um feed ao vivo e classificá-los para saber quais flores são reconhecidas pelo smartphone.

A partir daqui, as possibilidades são infinitas. E se você tiver seus próprios dados para algo que não seja flores, terá a base do que precisa para criar um app que as reconheça usando a visão computacional. Essas são apenas as primeiras etapas para um mundo muito mais amplo, e esperamos que você tenha gostado de trabalhar com elas.