Detectar objetos em imagens com o Kit de ML: Android

1. Antes de começar

O Kit de ML é um SDK para dispositivos móveis que leva a experiência em aprendizado de máquina no dispositivo do Google para apps Android e iOS. Você pode usar as APIs Vision e Natural Language, que são poderosas e fáceis de usar, para resolver desafios comuns nos seus apps ou criar experiências de usuário totalmente novas. Todos são alimentados pelos melhores modelos de ML do Google e oferecidos a você sem custo financeiro.

Todas as APIs do Kit de ML são executadas no dispositivo, permitindo casos de uso em tempo real em que você quer processar um stream da câmera ao vivo, por exemplo. Isso também significa que a funcionalidade está disponível off-line.

Este codelab vai mostrar etapas simples para adicionar detecção e rastreamento de objetos (ODT, na sigla em inglês) a uma determinada imagem no seu app Android. Este codelab usa alguns atalhos para destacar o uso da ODT do Kit de ML.

O que você vai criar

Neste codelab, você vai criar um app Android com o Kit de ML. Seu app vai usar a API Object Detection and Tracking do Kit de ML para detectar objetos em uma determinada imagem.No final, você vai ver algo semelhante à imagem à direita.

O que você vai aprender

Como integrar o SDK do Kit de ML ao seu app Android
API de detecção e rastreamento de objetos do Kit de ML

O que é necessário

Uma versão recente do Android Studio (v4.1.2 ou mais recente)
Emulador do Android Studio ou um dispositivo Android físico
Código de amostra
Conhecimento básico de desenvolvimento para Android em Kotlin.

Este codelab é focado no Kit de ML. Conceitos e blocos de códigos sem relevância não serão abordados. Eles são incluídos somente para você copiar e colar.

2. Começar a configuração

Fazer o download do código

Clique no link abaixo para fazer o download de todo o código para este codelab:

Descompacte o arquivo ZIP transferido por download. Isso descompacta uma pasta raiz (mlkit-android-main) com todos os recursos necessários. Neste codelab, você só vai precisar das fontes no subdiretório object-detection.

O subdiretório object-detection no repositório mlkit-android contém dois diretórios:

starter: o código inicial que você vai usar como base neste codelab.
final: código completo do app de exemplo finalizado.

3. Adicionar a API de detecção e rastreamento de objetos do Kit de ML ao projeto

Importar o app para o Android Studio

Vamos começar importando o app inicial para o Android Studio.

Abra o Android Studio, selecione Import Project (Gradle, Eclipse ADT, etc.) e escolha a pasta starter no código-fonte que você baixou anteriormente.

Adicione as dependências para detecção e rastreamento de objetos do Kit de ML

As dependências do Kit de ML permitem integrar o SDK de ODT do Kit de ML ao seu app. Adicione as seguintes linhas ao final do arquivo app/build.gradle do seu projeto:

build.gradle

dependencies {
  // ...
  implementation 'com.google.mlkit:object-detection:16.2.4'
}

Sincronize seu projeto com arquivos do Gradle

Para garantir que todas as dependências estejam disponíveis para seu app, sincronize o projeto com os arquivos do Gradle neste momento.

Selecione Sync Project with Gradle Files ( ) na barra de ferramentas do Android Studio.

(Se esse botão estiver desativado, importe apenas starter/app/build.gradle , não o repositório inteiro.)

4. Executar o app inicial

Agora que você importou o projeto para o Android Studio e adicionou as dependências para detecção e rastreamento de objetos do Kit de ML, já pode executar o app pela primeira vez.

Conecte o dispositivo Android via USB ao host ou inicie o emulador do Android Studio e clique em Executar ( ) na barra de ferramentas do Android Studio.

Executar e conhecer o app

O app será iniciado no dispositivo Android. Ele tem um código boilerplate para permitir que você capture uma foto ou selecione uma imagem predefinida e a envie para um pipeline de detecção e rastreamento de objetos que você vai criar neste codelab. Vamos conhecer um pouco o app antes de escrever o código.

Primeiro, há um Botão ( ) na parte de baixo para:

abra o app de câmera integrado ao dispositivo/emulador
tire uma foto no app de câmera
receber a imagem capturada no app inicial
mostrar a imagem

Teste o botão Tirar foto, siga as instruções para tirar uma foto, aceite a foto e observe como ela aparece no app inicial.

Repita algumas vezes para ver como funciona:

Em segundo lugar, há três imagens predefinidas que você pode escolher. Você pode usar essas imagens mais tarde para testar o código de detecção de objetos se estiver usando um emulador Android.

Selecione uma das três imagens predefinidas. Confira se a imagem aparece na visualização maior:

5. Adicionar detecção de objetos no dispositivo

Nesta etapa, você vai adicionar a funcionalidade ao app inicial para detectar objetos em imagens. Como você viu na etapa anterior, o app inicial contém código boilerplate para tirar fotos com o app de câmera no dispositivo. Há também três imagens predefinidas no app que você pode usar para testar a detecção de objetos se estiver executando o codelab em um emulador Android.

Depois de selecionar uma imagem, seja das imagens predefinidas ou tirando uma foto com o app de câmera, o código boilerplate decodifica essa imagem em uma instância Bitmap, mostra na tela e chama o método runObjectDetection com a imagem.

Nesta etapa, você vai adicionar código ao método runObjectDetection para fazer a detecção de objetos.

Configurar e executar a detecção de objetos no dispositivo em uma imagem

Há apenas três etapas simples com três APIs para configurar a ODT do Kit de ML:

preparar uma imagem: InputImage
crie um objeto detector: ObjectDetection.getClient(options)
conecte os dois objetos acima: process(image)

Isso é feito na função runObjectDetection(bitmap: Bitmap) do arquivo MainActivity.kt.

/**
 * ML Kit Object Detection Function
 */
private fun runObjectDetection(bitmap: Bitmap) {
}

No momento, a função está vazia. Siga as etapas abaixo para implementar a ODT do Kit de ML. Ao longo do processo, o Android Studio vai pedir que você adicione as importações necessárias:

com.google.mlkit.vision.common.InputImage
com.google.mlkit.vision.objects.ObjectDetection
com.google.mlkit.vision.objects.defaults.ObjectDetectorOptions

Etapa 1: criar um InputImage

O Kit de ML oferece uma API simples para criar um InputImage de um Bitmap. Em seguida, é possível inserir um InputImage nas APIs do Kit de ML.

// Step 1: create ML Kit's InputImage object
val image = InputImage.fromBitmap(bitmap, 0)

Adicione o código acima à parte de cima de runObjectDetection(bitmap:Bitmap).

Etapa 2: criar uma instância de detector

O Kit de ML segue o padrão de design do builder. Você vai transmitir a configuração para o builder e adquirir um detector dele. Há três opções de configuração (as opções em negrito são usadas neste codelab):

modo de detector (imagem única ou stream)
modo de detecção (única ou múltipla detecção de objetos)
modo de classificação (ativado ou desativado)

Este codelab é para detecção e classificação de vários objetos em uma única imagem. Adicione isso agora:

// Step 2: acquire detector object
val options = ObjectDetectorOptions.Builder()
   .setDetectorMode(ObjectDetectorOptions.SINGLE_IMAGE_MODE)
   .enableMultipleObjects()
   .enableClassification()
   .build()
val objectDetector = ObjectDetection.getClient(options)

Etapa 3: enviar imagens ao detector

A detecção e a classificação de objetos são processamentos assíncronos:

Você envia uma imagem para o detector (via process()).
O Detector trabalha bastante nisso.
O detector informa o resultado para você por um callback.

O código a seguir faz exatamente isso. Copie e adicione ao final ao código atual em fun runObjectDetection(bitmap:Bitmap)):

// Step 3: feed given image to detector and setup callback
objectDetector.process(image)
   .addOnSuccessListener {
       // Task completed successfully
        debugPrint(it)
   }
   .addOnFailureListener {
       // Task failed with an exception
       Log.e(TAG, it.message.toString())
   }

Ao concluir, o detector notifica você com:

O número total de objetos detectados. Cada objeto detectado é descrito com:
trackingId: um número inteiro usado para rastrear frames cruzados (NÃO usado neste codelab).
boundingBox: a caixa delimitadora do objeto.
labels: uma lista de rótulos para o objeto detectado (somente quando a classificação está ativada):
index (recebe o índice deste rótulo)
text (receba o texto deste rótulo, incluindo "Artigos de moda", "Alimentos", "Artigos para casa", "Lugar", "Planta")
confidence ( um ponto flutuante entre 0,0 e 1,0, em que 1,0 significa 100%)

Você provavelmente notou que o código faz um tipo de processamento printf para o resultado detectado com debugPrint().

Adicione-o à classe MainActivity:

private fun debugPrint(detectedObjects: List<DetectedObject>) {
   detectedObjects.forEachIndexed { index, detectedObject ->
       val box = detectedObject.boundingBox

       Log.d(TAG, "Detected object: $index")
       Log.d(TAG, " trackingId: ${detectedObject.trackingId}")
       Log.d(TAG, " boundingBox: (${box.left}, ${box.top}) - (${box.right},${box.bottom})")
       detectedObject.labels.forEach {
           Log.d(TAG, " categories: ${it.text}")
           Log.d(TAG, " confidence: ${it.confidence}")
       }
   }
}

Agora você já pode aceitar imagens para detecção.

Para executar o codelab, clique em Executar ( ) na barra de ferramentas do Android Studio. Selecione uma imagem predefinida ou tire uma foto e confira a janela logcat( ) dentro da IDE.

Você verá algo como:

D/MLKit Object Detection: Detected object: 0
D/MLKit Object Detection:  trackingId: null
D/MLKit Object Detection:  boundingBox: (481, 2021) - (2426,3376)
D/MLKit Object Detection:  categories: Food
D/MLKit Object Detection:  confidence: 0.90234375
D/MLKit Object Detection: Detected object: 1
D/MLKit Object Detection:  trackingId: null
D/MLKit Object Detection:  boundingBox: (2639, 2633) - (3058,3577)
D/MLKit Object Detection: Detected object: 2
D/MLKit Object Detection:  trackingId: null
D/MLKit Object Detection:  boundingBox: (3, 1816) - (615,2597)
D/MLKit Object Detection:  categories: Home good
D/MLKit Object Detection:  confidence: 0.75390625

...o que significa que o detector viu três objetos:

As categorias são Alimentos e Artigos para casa.
Não há categoria retornada para o segundo porque é uma classe desconhecida.
Nenhum trackingId (porque este é o modo de detecção de imagem única).
A posição dentro do retângulo boundingBox (por exemplo, (481, 2021) – (2426, 3376))
O detector está bem confiante de que o primeiro é um alimento (90% de confiança: era salada).

Tecnicamente, é tudo o que você precisa para fazer a detecção de objetos do Kit de ML funcionar: você já tem tudo o que precisa! Parabéns!

Na interface, você ainda está no estágio em que começou, mas pode usar os resultados detectados na interface, como desenhar a caixa delimitadora para criar uma experiência melhor. Vamos para a próxima etapa: pós-processar os resultados detectados.

6. Pós-processamento dos resultados da detecção

Nas etapas anteriores, você imprimiu o resultado detectado no logcat: simples e rápido.

Nesta seção, você vai usar o resultado na imagem:

desenhar a caixa delimitadora na imagem
extrair o nome da categoria e a confiança dentro da caixa delimitadora

Entender os utilitários de visualização

Há um código boilerplate no codelab para ajudar você a visualizar o resultado da detecção. Use essas utilidades para simplificar nosso código de visualização:

data class BoxWithText(val box: Rect, val text: String): uma classe de dados para armazenar um resultado de detecção de objetos para visualização. box é a caixa delimitadora em que o objeto está localizado, e text é a string de resultado da detecção a ser mostrada junto com a caixa delimitadora do objeto.
fun drawDetectionResult(bitmap: Bitmap, detectionResults: List<BoxWithText>): Bitmap Esse método extrai os resultados da detecção de objetos em detectionResults no bitmap de entrada e retorna a cópia modificada dele.

Confira um exemplo de saída do método utilitário drawDetectionResult:

Visualizar o resultado da detecção do Kit de ML

Use os utilitários de visualização para desenhar o resultado da detecção de objetos do Kit de ML sobre a imagem de entrada.

Acesse o local em que você chama debugPrint() e adicione o seguinte snippet de código abaixo dele:

// Parse ML Kit's DetectedObject and create corresponding visualization data
val detectedObjects = it.map { obj ->
    var text = "Unknown"

    // We will show the top confident detection result if it exist
    if (obj.labels.isNotEmpty()) {
        val firstLabel = obj.labels.first()
        text = "${firstLabel.text}, ${firstLabel.confidence.times(100).toInt()}%"
    }
    BoxWithText(obj.boundingBox, text)
}

// Draw the detection result on the input bitmap
val visualizedResult = drawDetectionResult(bitmap, detectedObjects)

// Show the detection result on the app screen
runOnUiThread {
    inputImageView.setImageBitmap(visualizedResult)
}

Comece analisando o DetectedObject do Kit de ML e criando uma lista de objetos BoxWithText para mostrar o resultado da visualização.
Em seguida, desenhe o resultado da detecção sobre a imagem de entrada usando o método utilitário drawDetectionResult e mostre na tela.

Executar

Agora clique em Executar ( ) na barra de ferramentas do Android Studio.

Depois que o app carregar, pressione o botão com o ícone da câmera, aponte a câmera para um objeto, tire uma foto e aceite a foto (no app Câmera) ou toque em qualquer uma das imagens predefinidas. Os resultados da detecção vão aparecer. Pressione o botão de novo ou selecione outra imagem para repetir algumas vezes e testar a versão mais recente da ODT do Kit de ML.

7. Parabéns!

Você usou o Kit de ML para adicionar recursos de detecção de objetos ao seu app:

Três etapas com três APIs
Criar imagem de entrada
Criar detector
Enviar imagem para o Detector

Isso é tudo o que você precisa para começar!

À medida que você avança, pode querer melhorar o modelo. Como você pode ver, o modelo padrão só reconhece cinco categorias. Ele nem sequer conhece faca, garfo e garrafa. Confira o outro codelab no nosso programa de cursos de aprendizado de máquina no dispositivo: detecção de objetos para saber como treinar um modelo personalizado.

O que vimos

Como adicionar a detecção e o rastreamento de objetos do Kit de ML ao seu app Android
Como usar a detecção e o rastreamento de objetos no dispositivo no Kit de ML para detectar objetos em imagens

Próximas etapas

Explore mais com o Kit de ML ODT com mais imagens e vídeos ao vivo para testar a precisão e a performance da detecção e da classificação.
Confira o programa de cursos Detecção de objetos do curso Machine learning no dispositivo para saber como treinar um modelo personalizado.
Aplicar a ODT do Kit de ML no seu próprio app Android

Saiba mais

https://developers.google.com/ml-kit/vision/object-detection