Détecter des objets dans des images avec un modèle entraîné par AutoML sur Android

Une fois que vous avez entraîné votre propre modèle à l'aide d'AutoML Vision Edge, vous pouvez l'utiliser dans votre application pour détecter des objets dans des images.

Il existe deux façons d'intégrer des modèles entraînés à partir d'AutoML Vision Edge: vous pouvez regrouper le modèle en le plaçant dans le dossier d'éléments de votre application, ou vous pouvez le télécharger de manière dynamique depuis Firebase.

Options de regroupement de modèles
Groupées dans votre application
  • Le modèle fait partie de l'APK de votre application
  • Le modèle est disponible immédiatement, même lorsque l'appareil Android est hors connexion.
  • Pas besoin d'un projet Firebase
Hébergement avec Firebase
  • Hébergez le modèle en l'important dans Firebase Machine Learning.
  • Réduction de la taille de l'APK
  • Le modèle est téléchargé à la demande
  • Transférer les mises à jour de modèle sans publier à nouveau votre application
  • Tests A/B faciles avec Firebase Remote Config
  • Nécessite un projet Firebase

Avant de commencer

  1. Si vous souhaitez télécharger un modèle, assurez-vous d'ajouter Firebase à votre projet Android, si ce n'est pas déjà fait. Cette étape n'est pas obligatoire lorsque vous groupez le modèle.

  2. Ajoutez les dépendances de la bibliothèque de tâches TensorFlow Lite au fichier Gradle au niveau de l'application de votre module, qui est généralement app/build.gradle:

    Pour regrouper un modèle avec votre application:

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

    Pour télécharger dynamiquement un modèle à partir de Firebase, ajoutez également la dépendance 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. Charger le modèle

Configurer une source de modèle locale

Pour regrouper le modèle avec votre application:

  1. Extrayez le modèle de l'archive ZIP que vous avez téléchargée à partir de la console Google Cloud.
  2. Incluez votre modèle dans le package de votre application :
    1. Si vous ne disposez pas d'un dossier d'éléments dans votre projet, créez-en un en effectuant un clic droit sur le dossier app/, puis en cliquant sur New > Folder > Assets Folder (Nouveau > Dossier > Dossier d'éléments).
    2. Copiez votre fichier de modèle tflite avec des métadonnées intégrées dans le dossier "assets".

  3. Ajoutez les éléments suivants au fichier build.gradle de votre application pour vous assurer que Gradle ne compresse pas le fichier de modèle lors de la compilation de l'application:

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

    Le fichier de modèle sera inclus dans le package de l'application et disponible en tant qu'élément brut.

Configurer une source de modèle hébergée par Firebase

Pour utiliser le modèle hébergé à distance, créez un objet RemoteModel en spécifiant le nom que vous avez attribué au modèle lorsque vous l'avez publié:

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()

Démarrez ensuite la tâche de téléchargement du modèle, en spécifiant les conditions dans lesquelles vous souhaitez autoriser le téléchargement. Si le modèle n'est pas sur l'appareil ou si une version plus récente du modèle est disponible, la tâche télécharge le modèle de manière asynchrone depuis 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.
    }

De nombreuses applications démarrent la tâche de téléchargement dans leur code d'initialisation, mais vous pouvez le faire à tout moment avant d'avoir besoin d'utiliser le modèle.

Créer un détecteur d'objets à partir de votre modèle

Après avoir configuré vos sources de modèle, créez un objet ObjectDetector à partir de l'une d'elles.

Si vous ne disposez que d'un modèle groupé localement, il vous suffit de créer un détecteur d'objets à partir de votre fichier de modèle et de configurer le seuil de score de confiance que vous souhaitez exiger (voir Évaluer votre modèle):

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)

Si vous disposez d'un modèle hébergé à distance, vous devez vérifier qu'il a été téléchargé avant de l'exécuter. Vous pouvez vérifier l'état de la tâche de téléchargement du modèle à l'aide de la méthode isModelDownloaded() du gestionnaire de modèles.

Bien que vous ne deviez le confirmer qu'avant d'exécuter le détecteur d'objets, si vous disposez à la fois d'un modèle hébergé à distance et d'un modèle groupé localement, il peut être judicieux d'effectuer cette vérification lors de l'instanciation du détecteur d'objets: créez un détecteur d'objets à partir du modèle distant s'il a été téléchargé, et à partir du modèle local dans le cas contraire.

Java

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

Kotlin

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

        }

Si vous ne disposez que d'un modèle hébergé à distance, vous devez désactiver les fonctionnalités liées au modèle (par exemple, griser ou masquer une partie de votre UI) jusqu'à ce que vous confirmiez que le modèle a été téléchargé. Pour ce faire, joignez un écouteur à la méthode download() du gestionnaire de modèles.

Une fois que vous savez que votre modèle a été téléchargé, créez un détecteur d'objets à partir du fichier de modèle:

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. Préparer l'image d'entrée

Ensuite, pour chaque image que vous souhaitez libeller, créez un objet TensorImage à partir de votre image. Vous pouvez créer un objet TensorImage à partir d'un Bitmap à l'aide de la méthode fromBitmap:

Java

TensorImage image = TensorImage.fromBitmap(bitmap);

Kotlin

val image = TensorImage.fromBitmap(bitmap)

Si vos données d'image ne se trouvent pas dans un Bitmap, vous pouvez charger un tableau de pixels, comme indiqué dans la documentation TensorFlow Lite.

3. Exécuter le détecteur d'objets

Pour détecter des objets dans une image, transmettez l'objet TensorImage à la méthode detect() de ObjectDetector.

Java

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

Kotlin

val results = objectDetector.detect(image)

4. Obtenir des informations sur les objets libellés

Si l'opération de détection d'objets aboutit, elle renvoie une liste d'objets Detection. Chaque objet Detection représente un élément détecté dans l'image. Vous pouvez obtenir le cadre de délimitation et les libellés de chaque objet.

Exemple :

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()
}

Conseils pour améliorer les performances en temps réel

Si vous souhaitez ajouter des libellés aux images dans une application en temps réel, suivez ces consignes pour obtenir les meilleurs fréquences d'images:

  • Limitez les appels à l'outil d'étiquetage d'images. Si un nouveau frame vidéo devient disponible pendant l'exécution du libelléur d'images, supprimez-le. Pour obtenir un exemple, consultez la classe VisionProcessorBase dans l'application exemple de démarrage rapide.
  • Si vous utilisez la sortie du libelléur d'images pour superposer des éléments graphiques à l'image d'entrée, obtenez d'abord le résultat, puis affichez l'image et la superposition en une seule étape. Vous ne procédez ainsi qu'une seule fois pour chaque frame d'entrée. Pour en savoir plus, consultez les classes CameraSourcePreview et GraphicOverlay dans l'application exemple de démarrage rapide.

  • Si vous utilisez l'API Camera2, capturez des images au format ImageFormat.YUV_420_888.

    Si vous utilisez l'ancienne API Camera, capturez des images au format ImageFormat.NV21.