Cette page a été traduite par l'API Cloud Translation.

Ajouter des libellés à des images avec un modèle entraîné automatiquement 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 ajouter des libellés aux 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é 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 sur Firebase Machine Learning. Réduit la taille de l'APK Le modèle est téléchargé à la demande Diffuser les mises à jour de modèle sans publier à nouveau votre application Tests A/B faciles avec Firebase Remote Config Nécessite un projet Firebase

Essayer

Testez l'application exemple pour voir un exemple d'utilisation de cette API.

Avant de commencer

1. Dans le fichier build.gradle de niveau projet, veillez à inclure le dépôt Maven de Google à la fois dans les sections buildscript et allprojects.

2. Ajoutez les dépendances des bibliothèques Android ML Kit au fichier Gradle de votre module au niveau de l'application, qui est généralement app/build.gradle : Pour regrouper un modèle avec votre application:

    dependencies {
      // ...
      // Image labeling feature with bundled automl model
      implementation 'com.google.mlkit:image-labeling-automl:16.2.1'
    }

Pour télécharger dynamiquement un modèle depuis Firebase, ajoutez la dépendance linkFirebase:

    dependencies {
      // ...
      // Image labeling feature with automl model downloaded
      // from firebase
      implementation 'com.google.mlkit:image-labeling-automl:16.2.1'
      implementation 'com.google.mlkit:linkfirebase:16.0.1'
    }

3. 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.

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 et ses métadonnées de l'archive ZIP que vous avez téléchargée depuis la console Firebase. Nous vous recommandons d'utiliser les fichiers tels que vous les avez téléchargés, sans modification (y compris les noms de fichiers).

2. Incluez votre modèle et ses fichiers de métadonnées dans votre package d'application:

a. 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).

b. Créez un sous-dossier dans le dossier d'éléments pour contenir les fichiers de modèle.

c. Copiez les fichiers model.tflite, dict.txt et manifest.json dans le sous-dossier (les trois fichiers doivent se trouver dans le même dossier).

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 pour ML Kit en tant qu'élément brut.

Remarque: À partir de la version 4.1 du plug-in Android Gradle, .tflite sera ajouté à la liste noCompress par défaut, et la section ci-dessus n'est plus nécessaire.

4. Créez un objet LocalModel en spécifiant le chemin d'accès au fichier manifeste du modèle:

KotlinJava

val localModel = AutoMLImageLabelerLocalModel.Builder()
        .setAssetFilePath("manifest.json")
        // or .setAbsoluteFilePath(absolute file path to manifest file)
        .build()

AutoMLImageLabelerLocalModel localModel =
    new AutoMLImageLabelerLocalModel.Builder()
        .setAssetFilePath("manifest.json")
        // or .setAbsoluteFilePath(absolute file path to manifest file)
        .build();

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é:

KotlinJava

// Specify the name you assigned in the Firebase console.
val remoteModel =
    AutoMLImageLabelerRemoteModel.Builder("your_model_name").build()

// Specify the name you assigned in the Firebase console.
AutoMLImageLabelerRemoteModel remoteModel =
    new AutoMLImageLabelerRemoteModel.Builder("your_model_name").build();

Ensuite, lancez la tâche de téléchargement du modèle, en spécifiant les conditions sous 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:

KotlinJava

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

DownloadConditions downloadConditions = new DownloadConditions.Builder()
        .requireWifi()
        .build();
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(@NonNull Task task) {
                // 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 outil de libellé d'image à partir de votre modèle

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

Si vous ne disposez que d'un modèle groupé localement, créez simplement un outil de libellé à partir de votre objet AutoMLImageLabelerLocalModel et configurez le seuil de score de confiance que vous souhaitez exiger (voir Évaluer votre modèle):

KotlinJava

val autoMLImageLabelerOptions = AutoMLImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0)  // Evaluate your model in the Firebase console
                                // to determine an appropriate value.
    .build()
val labeler = ImageLabeling.getClient(autoMLImageLabelerOptions)

AutoMLImageLabelerOptions autoMLImageLabelerOptions =
        new AutoMLImageLabelerOptions.Builder(localModel)
                .setConfidenceThreshold(0.0f)  // Evaluate your model in the Firebase console
                                               // to determine an appropriate value.
                .build();
ImageLabeler labeler = ImageLabeling.getClient(autoMLImageLabelerOptions)

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 l'outil de libellé, 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 de l'outil de libellé d'image: créez un outil de libellé à partir du modèle distant s'il a été téléchargé, et à partir du modèle local dans le cas contraire.

KotlinJava

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded -> 
    val optionsBuilder =
        if (isDownloaded) {
            AutoMLImageLabelerOptions.Builder(remoteModel)
        } else {
            AutoMLImageLabelerOptions.Builder(localModel)
        }
    // Evaluate your model in the Firebase console to determine an appropriate threshold.
    val options = optionsBuilder.setConfidenceThreshold(0.0f).build()
    val labeler = ImageLabeling.getClient(options)
}

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
                AutoMLImageLabelerOptions.Builder optionsBuilder;
                if (isDownloaded) {
                    optionsBuilder = new AutoMLImageLabelerOptions.Builder(remoteModel);
                } else {
                    optionsBuilder = new AutoMLImageLabelerOptions.Builder(localModel);
                }
                AutoMLImageLabelerOptions options = optionsBuilder
                        .setConfidenceThreshold(0.0f)  // Evaluate your model in the Firebase console
                                                       // to determine an appropriate threshold.
                        .build();

                ImageLabeler labeler = ImageLabeling.getClient(options);
            }
        });

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:

KotlinJava

RemoteModelManager.getInstance().download(remoteModel, conditions)
    .addOnSuccessListener {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.
    }

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Void v) {
              // Download complete. Depending on your app, you could enable
              // the ML feature, or switch from the local model to the remote
              // model, etc.
            }
        });

2. Préparer l'image d'entrée

Ensuite, pour chaque image que vous souhaitez libeller, créez un objet InputImage à partir de votre image. L'outil de libellé d'image s'exécute plus rapidement lorsque vous utilisez un Bitmap ou, si vous utilisez l'API camera2, un media.Image YUV_420_888, qui sont recommandés dans la mesure du possible.

Vous pouvez créer un objet InputImage à partir de différentes sources, chacune étant expliquée ci-dessous.

Utiliser un `media.Image`

Pour créer un objet InputImage à partir d'un objet media.Image, par exemple lorsque vous capturez une image à partir de l'appareil photo d'un appareil, transmettez l'objet media.Image et la rotation de l'image à InputImage.fromMediaImage().

Si vous utilisez la bibliothèque CameraX, les classes OnImageCapturedListener et ImageAnalysis.Analyzer calculent la valeur de rotation à votre place.

KotlinJava

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

Si vous n'utilisez pas de bibliothèque d'appareil photo qui vous indique le degré de rotation de l'image, vous pouvez le calculer à partir du degré de rotation de l'appareil et de l'orientation du capteur de l'appareil photo dans l'appareil:

KotlinJava

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, isFrontFacing: Boolean): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}MLKitVisionImage.kt

private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 0);
    ORIENTATIONS.append(Surface.ROTATION_90, 90);
    ORIENTATIONS.append(Surface.ROTATION_180, 180);
    ORIENTATIONS.append(Surface.ROTATION_270, 270);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, boolean isFrontFacing)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

Transmettez ensuite l'objet media.Image et la valeur de degré de rotation à InputImage.fromMediaImage():

KotlinJava

val image = InputImage.fromMediaImage(mediaImage, rotation)MLKitVisionImage.kt

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

Utiliser un URI de fichier

Pour créer un objet InputImage à partir d'un URI de fichier, transmettez le contexte de l'application et l'URI de fichier à InputImage.fromFilePath(). Cela est utile lorsque vous utilisez un intent ACTION_GET_CONTENT pour inviter l'utilisateur à sélectionner une image dans son application Galerie.

KotlinJava

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}MLKitVisionImage.kt

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

Utiliser un `ByteBuffer` ou un `ByteArray`

Pour créer un objet InputImage à partir d'un ByteBuffer ou d'un ByteArray, commencez par calculer le degré de rotation de l'image comme décrit précédemment pour l'entrée media.Image. Créez ensuite l'objet InputImage avec le tampon ou le tableau, ainsi que la hauteur, la largeur, le format d'encodage des couleurs et le degré de rotation de l'image:

KotlinJava

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)MLKitVisionImage.kt
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);MLKitVisionImage.java
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);MLKitVisionImage.java

Utiliser un `Bitmap`

Pour créer un objet InputImage à partir d'un objet Bitmap, effectuez la déclaration suivante:

KotlinJava

val image = InputImage.fromBitmap(bitmap, 0)MLKitVisionImage.kt

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);MLKitVisionImage.java

L'image est représentée par un objet Bitmap avec les degrés de rotation.

3. Exécuter l'outil de libellé d'image

Pour ajouter des libellés aux objets d'une image, transmettez l'objet image à la méthode process() de ImageLabeler.

KotlinJava

labeler.process(image)
        .addOnSuccessListener { labels ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }ImageLabelingActivity.kt

labeler.process(image)
        .addOnSuccessListener(new OnSuccessListener<List<ImageLabel>>() {
            @Override
            public void onSuccess(List<ImageLabel> labels) {
                // Task completed successfully
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
            }
        });ImageLabelingActivity.java

Remarque: Si vous utilisez l'API CameraX, veillez à fermer le ImageProxy lorsque vous avez fini de l'utiliser, par exemple en ajoutant un OnCompleteListener au Task renvoyé par la méthode process. Pour obtenir un exemple, consultez la classe VisionProcessorBase dans l'application exemple de démarrage rapide.

4. Obtenir des informations sur les objets libellés

Si l'opération de libellé d'image aboutit, une liste d'objets ImageLabel est transmise à l'écouteur de réussite. Chaque objet ImageLabel représente un élément qui a été libellé dans l'image. Vous pouvez obtenir la description textuelle de chaque étiquette, le score de confiance de la correspondance et l'indice de la correspondance. Exemple :

KotlinJava

for (label in labels) {
    val text = label.text
    val confidence = label.confidence
    val index = label.index
}ImageLabelingActivity.kt

for (ImageLabel label : labels) {
    String text = label.getText();
    float confidence = label.getConfidence();
    int index = label.getIndex();
}ImageLabelingActivity.java

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:

Si vous utilisez l'API Camera ou camera2, limitez les appels à l'outil de libellé d'image. 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 l'API CameraX, assurez-vous que la stratégie de contre-pression est définie sur sa valeur par défaut, ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Cela garantit qu'une seule image sera envoyée pour analyse à la fois. Si d'autres images sont produites lorsque l'analyseur est occupé, elles seront supprimées automatiquement et ne seront pas mises en file d'attente pour la diffusion. Une fois l'image analysée fermée en appelant ImageProxy.close(), la dernière image est envoyée.
Si vous utilisez la sortie du libelléur d'image pour superposer des éléments graphiques à l'image d'entrée, obtenez d'abord le résultat de ML Kit, puis affichez l'image et la superposition en une seule étape. Le rendu n'est effectué sur la surface d'affichage 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.

Ajouter des libellés à des images avec un modèle entraîné automatiquement sur Android

Essayer

Avant de commencer

1. Charger le modèle

Configurer une source de modèle locale

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

Créer un outil de libellé d'image à partir de votre modèle

2. Préparer l'image d'entrée

Utiliser un media.Image

Utiliser un URI de fichier

Utiliser un ByteBuffer ou un ByteArray

Utiliser un Bitmap

3. Exécuter l'outil de libellé d'image

4. Obtenir des informations sur les objets libellés

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

Utiliser un `media.Image`

Utiliser un `ByteBuffer` ou un `ByteArray`

Utiliser un `Bitmap`