Início rápido para Android

Este tutorial mostra como criar um aplicativo Android usando o TensorFlow Lite para analisar um feed de câmera ao vivo e identificar objetos usando um modelo de aprendizado de máquina, usando uma quantidade mínima de código. Se você estiver atualizando um projeto existente, poderá usar o exemplo de código como referência e pular para as instruções para modificar seu projeto .

Detecção de objetos com aprendizado de máquina

Demonstração animada de detecção de objetos O modelo de aprendizado de máquina neste tutorial executa a detecção de objetos. Um modelo de detecção de objetos pega dados de imagem em um formato específico, analisa-os e tenta categorizar itens na imagem como um de um conjunto de classes conhecidas que ele foi treinado para reconhecer. A velocidade com que um modelo pode identificar um objeto conhecido (chamado de predição ou inferência de objeto) é geralmente medida em milissegundos. Na prática, a velocidade de inferência varia de acordo com o hardware que hospeda o modelo, o tamanho dos dados processados ​​e o tamanho do modelo de aprendizado de máquina.

Exemplo de configuração e execução

Para a primeira parte deste tutorial, baixe o exemplo do GitHub e execute-o usando o Android Studio . As seções a seguir deste tutorial exploram as seções relevantes do exemplo de código, para que você possa aplicá-las aos seus próprios aplicativos Android. Você precisa das seguintes versões dessas ferramentas instaladas:

  • Android Studio 4.2.2 ou superior
  • Android SDK versão 31 ou superior

Obtenha o código de exemplo

Crie uma cópia local do código de exemplo. Você usará esse código para criar um projeto no Android Studio e executar o aplicativo de amostra.

Para clonar e configurar o código de exemplo:

  1. Clone o repositório git
    git clone https://github.com/android/camera-samples.git
    
  2. Configure sua instância do git para usar check-out esparso, para que você tenha apenas os arquivos para o aplicativo de exemplo de detecção de objetos:

    cd camera-samples
    git sparse-checkout init --cone
    git sparse-checkout set CameraXAdvanced
    

Importar e executar o projeto

Crie um projeto a partir do código de exemplo baixado, compile o projeto e execute-o.

Para importar e construir o projeto de código de exemplo:

  1. Inicie o Android Studio .
  2. Na página de boas- vindas do Android Studio, escolha Import Project ou selecione File > New > Import Project .
  3. Navegue até o diretório de código de exemplo que contém o arquivo build.gradle ( .../android/camera-samples/CameraXAdvanced/build.gradle ) e selecione esse diretório.

Se você selecionar o diretório correto, o Android Studio cria um novo projeto e o compila. Esse processo pode levar alguns minutos, dependendo da velocidade do seu computador e se você já usou o Android Studio para outros projetos. Quando a compilação for concluída, o Android Studio exibirá uma mensagem BUILD SUCCESSFUL no painel de status Build Output .

Opcional: para corrigir erros de compilação atualizando a versão do plug-in do Android:

  1. Abra o arquivo build.gradle no diretório do projeto.
  2. Altere a versão das ferramentas do Android da seguinte maneira:

    // from:
    classpath 'com.android.tools.build:gradle:4.2.2'
    // to:
    classpath 'com.android.tools.build:gradle:4.1.2'
    
  3. Sincronize o projeto selecionando: File > Sync Project with Gradle Files .

Para executar o projeto:

  1. No Android Studio, execute o projeto selecionando Run > Run… e CameraActivity .
  2. Selecione um dispositivo Android conectado com uma câmera para testar o aplicativo.

As próximas seções mostram as modificações que você precisa fazer em seu projeto existente para adicionar essa funcionalidade ao seu próprio aplicativo, usando este aplicativo de exemplo como ponto de referência.

Adicionar dependências do projeto

Em seu próprio aplicativo, você deve adicionar dependências de projeto específicas para executar modelos de aprendizado de máquina do TensorFlow Lite e acessar funções de utilitário que convertem dados, como imagens, em um formato de dados de tensor que pode ser processado pelo modelo que você está usando.

O aplicativo de exemplo usa várias bibliotecas do TensorFlow Lite para permitir a execução do modelo de aprendizado de máquina de detecção de objetos:

  • Biblioteca principal do TensorFlow Lite - fornece as classes de entrada de dados necessárias, execução do modelo de aprendizado de máquina e resultados de saída do processamento do modelo.
  • Biblioteca de suporte do TensorFlow Lite - essa biblioteca fornece uma classe auxiliar para traduzir imagens da câmera em um objeto de dados do TensorImage que pode ser processado pelo modelo de aprendizado de máquina.
  • Biblioteca de GPU do TensorFlow Lite - essa biblioteca oferece suporte para acelerar a execução do modelo usando processadores de GPU no dispositivo, se estiverem disponíveis.

As instruções a seguir explicam como adicionar as dependências necessárias do projeto e do módulo ao seu próprio projeto de aplicativo Android.

Para adicionar dependências de módulo:

  1. No módulo que usa o TensorFlow Lite, atualize o arquivo build.gradle do módulo para incluir as dependências a seguir. No código de exemplo, este arquivo está localizado aqui: .../android/camera-samples/CameraXAdvanced/tflite/build.gradle ( referência de código )

    ...
    dependencies {
    ...
        // Tensorflow lite dependencies
        implementation 'org.tensorflow:tensorflow-lite:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-support:2.8.0'
    ...
    }
    
  2. No Android Studio, sincronize as dependências do projeto selecionando: File > Sync Project with Gradle Files .

Inicialize o interpretador de modelo de ML

No seu aplicativo Android, você deve inicializar o interpretador de modelo de aprendizado de máquina do TensorFlow Lite com parâmetros antes de executar previsões com o modelo. Esses parâmetros de inicialização dependem do modelo que você está usando e podem incluir configurações como limites mínimos de precisão para previsões e rótulos para classes de objetos identificadas.

Um modelo do TensorFlow Lite inclui um arquivo .tflite contendo o código do modelo e frequentemente inclui um arquivo de rótulos contendo os nomes das classes previstas pelo modelo. No caso de detecção de objetos, as classes são objetos como uma pessoa, cachorro, gato ou carro. Os modelos geralmente são armazenados no diretório src/main/assets do módulo primário, como no exemplo de código:

  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_quant.tflite
  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_labels.txt

Por conveniência e legibilidade do código, o exemplo declara um objeto complementar que define as configurações do modelo.

Para inicializar o modelo em seu aplicativo:

  1. Crie um objeto complementar para definir as configurações do modelo: ( referência de código )

    companion object {
       private val TAG = CameraActivity::class.java.simpleName
    
       private const val ACCURACY_THRESHOLD = 0.5f
       private const val MODEL_PATH = "coco_ssd_mobilenet_v1_1.0_quant.tflite"
       private const val LABELS_PATH = "coco_ssd_mobilenet_v1_1.0_labels.txt"
    }
    
  2. Use as configurações deste objeto para construir um objeto TensorFlow Lite Interpreter que contém o modelo: ( referência de código )

    private val tflite by lazy {
       Interpreter(
           FileUtil.loadMappedFile(this, MODEL_PATH),
           Interpreter.Options().addDelegate(nnApiDelegate))
    }
    

Configurar acelerador de hardware

Ao inicializar um modelo do TensorFlow Lite em seu aplicativo, você pode usar os recursos de aceleração de hardware para acelerar os cálculos de previsão do modelo. O exemplo de código acima usa o NNAPI Delegate para lidar com a aceleração de hardware da execução do modelo:

Interpreter.Options().addDelegate(nnApiDelegate)

Os delegados do TensorFlow Lite são módulos de software que aceleram a execução de modelos de machine learning usando hardware de processamento especializado em um dispositivo móvel, como GPUs, TPUs ou DSPs. O uso de representantes para executar modelos do TensorFlow Lite é recomendado, mas não obrigatório.

Para obter mais informações sobre como usar representantes com o TensorFlow Lite, consulte Delegados do TensorFlow Lite .

Fornecer dados para o modelo

Em seu aplicativo Android, seu código fornece dados ao modelo para interpretação, transformando dados existentes, como imagens, em um formato de dados do Tensor que pode ser processado por seu modelo. Os dados em um tensor devem ter dimensões ou formas específicas que correspondam ao formato de dados usado para treinar o modelo.

Para determinar a forma de tensor necessária para um modelo:

  • Use o objeto Interpreter inicializado para determinar a forma do tensor usado pelo seu modelo, conforme mostrado no trecho de código abaixo: ( code reference )

    private val tfInputSize by lazy {
       val inputIndex = 0
       val inputShape = tflite.getInputTensor(inputIndex).shape()
       Size(inputShape[2], inputShape[1]) // Order of axis is: {1, height, width, 3}
    }
    

O modelo de detecção de objetos usado no código de exemplo espera imagens quadradas com tamanho de 300 por 300 pixels.

Antes que você possa fornecer imagens da câmera, seu aplicativo deve obter a imagem, ajustá-la ao tamanho esperado, ajustar sua rotação e normalizar os dados da imagem. Ao processar imagens com um modelo do TensorFlow Lite, você pode usar a classe ImageProcessor da Biblioteca de suporte do TensorFlow Lite para lidar com esse pré-processamento de dados, conforme mostrado abaixo.

Para transformar dados de imagem para um modelo:

  1. Use o ImageProcessor da Biblioteca de Suporte para criar um objeto para transformar dados de imagem em um formato que seu modelo possa usar para executar previsões: ( referência de código )

    private val tfImageProcessor by lazy {
       val cropSize = minOf(bitmapBuffer.width, bitmapBuffer.height)
       ImageProcessor.Builder()
           .add(ResizeWithCropOrPadOp(cropSize, cropSize))
           .add(ResizeOp(
               tfInputSize.height, tfInputSize.width, ResizeOp.ResizeMethod.NEAREST_NEIGHBOR))
           .add(Rot90Op(-imageRotationDegrees / 90))
           .add(NormalizeOp(0f, 1f))
           .build()
    }
    
  2. Copie os dados da imagem do sistema da câmera Android e prepare-os para análise com seu objeto ImageProcessor : ( referência de código )

    // Copy out RGB bits to the shared buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)  }
    
    // Process the image in Tensorflow
    val tfImage =  tfImageProcessor.process(tfImageBuffer.apply { load(bitmapBuffer) })
    

Executar previsões

No seu aplicativo Android, depois de criar um objeto TensorImage com dados de imagem no formato correto, você pode executar o modelo nesses dados para produzir uma previsão ou inferência . O código de exemplo para este tutorial usa uma classe ObjectDetectionHelper que encapsula esse código em um método predict() .

Para executar uma previsão em um conjunto de dados de imagem:

  1. Execute a previsão passando os dados da imagem para sua função de previsão: ( referência de código )

    // Perform the object detection for the current frame
    val predictions = detector.predict(tfImage)
    
  2. Chame o método run em sua instância de objeto tflite com os dados da imagem para gerar previsões: ( referência de código )

    fun predict(image: TensorImage): List<ObjectPrediction> {
       tflite.runForMultipleInputsOutputs(arrayOf(image.buffer), outputBuffer)
       return predictions
    }
    

O objeto TensorFlow Lite Interpreter recebe esses dados, executa-os no modelo e produz uma lista de previsões. Para processamento contínuo de dados pelo modelo, use o método runForMultipleInputsOutputs() para que os objetos Interpreter não sejam criados e removidos pelo sistema para cada execução de previsão.

Lidar com a saída do modelo

Em seu aplicativo Android, depois de executar dados de imagem no modelo de detecção de objetos, ele produz uma lista de previsões que o código do aplicativo deve processar executando lógica de negócios adicional, exibindo resultados para o usuário ou realizando outras ações.

A saída de qualquer modelo do TensorFlow Lite varia de acordo com o número de previsões que ele produz (uma ou muitas) e as informações descritivas de cada previsão. No caso de um modelo de detecção de objetos, as previsões normalmente incluem dados para uma caixa delimitadora que indica onde um objeto é detectado na imagem. No código de exemplo, os dados retornados são formatados como uma lista de objetos ObjectPrediction , conforme mostrado abaixo: ( code reference )

val predictions get() = (0 until OBJECT_COUNT).map {
   ObjectPrediction(

       // The locations are an array of [0, 1] floats for [top, left, bottom, right]
       location = locations[0][it].let {
           RectF(it[1], it[0], it[3], it[2])
       },

       // SSD Mobilenet V1 Model assumes class 0 is background class
       // in label file and class labels start from 1 to number_of_classes + 1,
       // while outputClasses correspond to class index from 0 to number_of_classes
       label = labels[1 + labelIndices[0][it].toInt()],

       // Score is a single value of [0, 1]
       score = scores[0][it]
   )
}

Captura de tela de detecção de objetos Para o modelo usado neste exemplo, cada previsão inclui um local de caixa delimitadora para o objeto, um rótulo para o objeto e uma pontuação de previsão entre 0 e 1 como um Float representando a confiança da previsão, sendo 1 a classificação de confiança mais alta . Em geral, as previsões com pontuação abaixo de 50% (0,5) são consideradas inconclusivas. No entanto, a forma como você lida com resultados de previsão de baixo valor depende de você e das necessidades do seu aplicativo.

Depois que o modelo retornar um resultado de previsão, seu aplicativo poderá agir nessa previsão apresentando o resultado ao usuário ou executando lógica adicional. No caso do código de exemplo, o aplicativo desenha uma caixa delimitadora ao redor do objeto identificado e exibe o nome da classe na tela. Revise a função CameraActivity.reportPrediction() no código de exemplo para obter detalhes.

Próximos passos

  • Explore vários usos do TensorFlow Lite nos exemplos .
  • Saiba mais sobre como usar modelos de machine learning com o TensorFlow Lite na seção Modelos .
  • Saiba mais sobre como implementar o aprendizado de máquina em seu aplicativo móvel no Guia do desenvolvedor do TensorFlow Lite .