Detectar objetos em imagens com um modelo treinado em AutoML no Android

Depois de treinar seu próprio modelo usando o AutoML Vision Edge , você pode usá-lo em seu aplicativo para detectar objetos em imagens.

Há duas maneiras de integrar modelos treinados no AutoML Vision Edge: você pode agrupar o modelo colocando-o dentro da pasta de ativos do seu aplicativo ou fazer o download dinamicamente do Firebase.

Opções de agrupamento de modelos
Agrupado em seu aplicativo
  • O modelo faz parte do APK do seu app
  • O modelo está disponível imediatamente, mesmo quando o dispositivo Android está offline
  • Não há necessidade de um projeto do Firebase
Hospedado com Firebase
  • Hospede o modelo fazendo upload para o Firebase Machine Learning
  • Reduz o tamanho do APK
  • O modelo é baixado sob demanda
  • Envie atualizações de modelo sem republicar seu aplicativo
  • Testes A/B fáceis com o Firebase Remote Config
  • Requer um projeto do Firebase

Antes de você começar

  1. Se você quiser fazer o download de um modelo , certifique-se de adicionar o Firebase ao seu projeto Android , caso ainda não o tenha feito. Isso não é necessário quando você agrupa o modelo.

  2. Adicione as dependências da biblioteca de tarefas do TensorFlow Lite ao arquivo gradle no nível do aplicativo do seu módulo, que geralmente é app/build.gradle :

    Para agrupar um modelo com seu aplicativo:

    dependencies {
      // ...
      // Object detection with a bundled Auto ML model
      implementation 'org.tensorflow:tensorflow-lite-task-vision:0.0.0-nightly-SNAPSHOT'
    }
    

    Para baixar dinamicamente um modelo do Firebase, adicione também a dependência do Firebase ML:

    dependencies {
      // ...
      // Object detection with an Auto ML model deployed to Firebase
      implementation platform('com.google.firebase:firebase-bom:26.1.1')
      implementation 'com.google.firebase:firebase-ml-model-interpreter'
    
      implementation 'org.tensorflow:tensorflow-lite-task-vision:0.0.0-nightly'
    }
    

1. Carregue o modelo

Configurar uma fonte de modelo local

Para agrupar o modelo com seu aplicativo:

  1. Extraia o modelo do arquivo zip que você baixou do Console do Google Cloud.
  2. Inclua seu modelo no pacote do seu aplicativo:
    1. Se você não tiver uma pasta de ativos em seu projeto, crie uma clicando com o botão direito do mouse na pasta app/ e clicando em Novo > Pasta > Pasta de ativos .
    2. Copie seu arquivo de modelo tflite com metadados incorporados para a pasta de ativos.
  3. Adicione o seguinte ao arquivo build.gradle do seu aplicativo para garantir que o Gradle não comprima o arquivo de modelo ao compilar o aplicativo:

    android {
        // ...
        aaptOptions {
            noCompress "tflite"
        }
    }
    

    O arquivo de modelo será incluído no pacote do aplicativo e estará disponível como um ativo bruto.

Configurar uma origem de modelo hospedada pelo Firebase

Para usar o modelo hospedado remotamente, crie um objeto RemoteModel , especificando o nome que você atribuiu ao modelo quando o publicou:

Java

// Specify the name you assigned when you deployed the model.
FirebaseCustomRemoteModel remoteModel =
        new FirebaseCustomRemoteModel.Builder("your_model").build();

Kotlin

// Specify the name you assigned when you deployed the model.
val remoteModel =
    FirebaseCustomRemoteModel.Builder("your_model_name").build()

Em seguida, inicie a tarefa de download do modelo, especificando as condições sob as quais você deseja permitir o download. Se o modelo não estiver no dispositivo ou se uma versão mais recente do modelo estiver disponível, a tarefa fará o download do modelo de forma assíncrona do Firebase:

Java

DownloadConditions downloadConditions = new DownloadConditions.Builder()
        .requireWifi()
        .build();
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(@NonNull Task<Void> task) {
                // Success.
            }
        });

Kotlin

val downloadConditions = DownloadConditions.Builder()
    .requireWifi()
    .build()
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
    .addOnSuccessListener {
        // Success.
    }

Muitos aplicativos iniciam a tarefa de download em seu código de inicialização, mas você pode fazer isso a qualquer momento antes de precisar usar o modelo.

Crie um detector de objetos a partir do seu modelo

Depois de configurar suas fontes de modelo, crie um objeto ObjectDetector a partir de uma delas.

Se você tiver apenas um modelo empacotado localmente, basta criar um detector de objetos a partir de seu arquivo de modelo e configurar o limite de pontuação de confiança que deseja exigir (consulte Avaliar seu modelo ):

Java

// Initialization
ObjectDetectorOptions options = ObjectDetectorOptions.builder()
    .setScoreThreshold(0)  // Evaluate your model in the Google Cloud Console
                           // to determine an appropriate value.
    .build();
ObjectDetector objectDetector = ObjectDetector.createFromFileAndOptions(context, modelFile, options);

Kotlin

// Initialization
val options = ObjectDetectorOptions.builder()
    .setScoreThreshold(0)  // Evaluate your model in the Google Cloud Console
                           // to determine an appropriate value.
    .build()
val objectDetector = ObjectDetector.createFromFileAndOptions(context, modelFile, options)

Se você tiver um modelo hospedado remotamente, precisará verificar se foi baixado antes de executá-lo. Você pode verificar o status da tarefa de download do modelo usando o método isModelDownloaded() do gerenciador de modelo.

Embora você só precise confirmar isso antes de executar o detector de objetos, se você tiver um modelo hospedado remotamente e um modelo empacotado localmente, pode fazer sentido realizar esta verificação ao instanciar o detector de objetos: crie um detector de objetos do controle remoto model se tiver sido baixado e do modelo local caso contrário.

Java

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener<Boolean>() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
            }
        });

Kotlin

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener { success ->

        }

Se você tiver apenas um modelo hospedado remotamente, deverá desabilitar a funcionalidade relacionada ao modelo — por exemplo, acinzentado ou ocultar parte de sua interface do usuário — até confirmar que o modelo foi baixado. Você pode fazer isso anexando um ouvinte ao método download() do gerenciador de modelos.

Depois de saber que seu modelo foi baixado, crie um detector de objetos a partir do arquivo de modelo:

Java

FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
        .addOnCompleteListener(new OnCompleteListener<File>() {
            @Override
            public void onComplete(@NonNull Task<File> task) {
                File modelFile = task.getResult();
                if (modelFile != null) {
                    ObjectDetectorOptions options = ObjectDetectorOptions.builder()
                            .setScoreThreshold(0)
                            .build();
                    objectDetector = ObjectDetector.createFromFileAndOptions(
                            getApplicationContext(), modelFile.getPath(), options);
                }
            }
        });

Kotlin

FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
        .addOnSuccessListener { modelFile ->
            val options = ObjectDetectorOptions.builder()
                    .setScoreThreshold(0f)
                    .build()
            objectDetector = ObjectDetector.createFromFileAndOptions(
                    applicationContext, modelFile.path, options)
        }

2. Prepare a imagem de entrada

Em seguida, para cada imagem que você deseja rotular, crie um objeto TensorImage da sua imagem. Você pode criar um objeto TensorImage de um Bitmap usando o método fromBitmap :

Java

TensorImage image = TensorImage.fromBitmap(bitmap);

Kotlin

val image = TensorImage.fromBitmap(bitmap)

Se os dados da sua imagem não estiverem em um Bitmap , você poderá carregar uma matriz de pixels conforme mostrado nos documentos do TensorFlow Lite .

3. Execute o detector de objetos

Para detectar objetos em uma imagem, passe o objeto TensorImage para o método detect() do ObjectDetector .

Java

List<Detection> results = objectDetector.detect(image);

Kotlin

val results = objectDetector.detect(image)

4. Obtenha informações sobre objetos rotulados

Se a operação de detecção de objetos for bem-sucedida, ela retornará uma lista de objetos de Detection . Cada objeto Detection representa algo que foi detectado na imagem. Você pode obter a caixa delimitadora de cada objeto e seus rótulos.

Por exemplo:

Java

for (Detection result : results) {
    RectF bounds = result.getBoundingBox();
    List<Category> labels = result.getCategories();
}

Kotlin

for (result in results) {
    val bounds = result.getBoundingBox()
    val labels = result.getCategories()
}

Dicas para melhorar o desempenho em tempo real

Se você deseja rotular imagens em um aplicativo em tempo real, siga estas diretrizes para obter as melhores taxas de quadros:
  • Acelere as chamadas para o rotulador de imagem. Se um novo quadro de vídeo ficar disponível enquanto o rotulador de imagem estiver em execução, solte o quadro. Consulte a classe VisionProcessorBase no aplicativo de exemplo de início rápido para obter um exemplo.
  • Se você estiver usando a saída do rotulador de imagem para sobrepor gráficos na imagem de entrada, primeiro obtenha o resultado e depois renderize a imagem e a sobreposição em uma única etapa. Ao fazer isso, você renderiza para a superfície de exibição apenas uma vez para cada quadro de entrada. Consulte as classes CameraSourcePreview e GraphicOverlay no aplicativo de exemplo de início rápido para obter um exemplo.
  • Se você usar a API Camera2, capture imagens no formato ImageFormat.YUV_420_888 .

    Se você usa a API de câmera mais antiga, capture imagens no formato ImageFormat.NV21 .