Étiqueter des images avec un modèle entraîné par AutoML sur Android

Une fois que vous formez votre propre modèle en utilisant AutoML Vision bord , vous pouvez l' utiliser dans votre application pour les images de l' étiquette.

Il existe deux manières 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 des ressources de votre application, ou vous pouvez le télécharger dynamiquement à partir de Firebase.

Options de regroupement de modèles
Intégré à 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 ligne
  • Pas besoin d'un projet Firebase
Hébergé avec Firebase
  • Hôte le modèle en le téléchargeant à Firebase Machine Learning
  • Réduit la taille de l'APK
  • Le modèle est téléchargé à la demande
  • Pousser les mises à jour du modèle sans republier votre application
  • Facile test A / B avec Firebase à distance Config
  • Nécessite un projet Firebase

Avant que tu commences

  1. Ajoutez les dépendances pour les bibliothèques ML Kit Android au fichier gradle au niveau de l' application de votre module, ce 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-custom:16.3.1'
    }
    

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

    dependencies {
      // ...
      // Image labeling feature with automl model downloaded
      // from firebase
      implementation 'com.google.mlkit:image-labeling-custom:16.3.1'
      implementation 'com.google.mlkit:linkfirebase:16.1.0'
    }
    
  2. Si vous voulez télécharger un modèle, assurez-vous d' ajouter Firebase à votre projet Android , si vous ne l' avez pas déjà fait. Cela n'est pas nécessaire lorsque vous regroupez le modèle.

1. Chargez 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 à partir de 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 :

    1. Si vous ne disposez pas d' un dossier actif dans votre projet, créez un clic droit sur l' app/ dossier, puis en cliquant sur Nouveau> Dossier> Dossier actif.
    2. Créez un sous-dossier sous le dossier des actifs pour contenir les fichiers de modèle.
    3. Copiez les fichiers model.tflite , dict.txt et manifest.json au sous-dossier (tous les trois fichiers doivent être dans le même dossier).
  3. Ajoutez ce qui suit votre application build.gradle fichier pour assurer Gradle ne permet pas de compresser le fichier de modèle lors de la construction de l'application:

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

    Le fichier modèle sera inclus dans le package de l'application et disponible pour ML Kit en tant qu'actif brut.

  4. Créer LocalModel objet, en spécifiant le chemin d'accès au fichier manifeste de modèle:

    Java

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

    Kotlin

    val localModel = LocalModel.Builder()
        .setAssetManifestFilePath("manifest.json")
        // or .setAbsoluteManifestFilePath(absolute file path to manifest file)
        .build()
    

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

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

Java

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

Kotlin

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

Ensuite, lancez 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 ne se trouve pas sur l'appareil ou si une version plus récente du modèle est disponible, la tâche téléchargera de manière asynchrone le modèle 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 de devoir utiliser le modèle.

Créez une étiqueteuse d'images à partir de votre modèle

Après avoir configuré vos sources de modèle, créez un ImageLabeler objet d'un d'entre eux.

Si vous avez seulement un modèle fourni localement, il suffit de créer une étiqueteuse de votre CustomImageLabelerOptions objet et configurer le seuil de score de confiance que vous voulez exiger (voir Évaluer votre modèle ):

Java

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

Kotlin

val customImageLabelerOptions = CustomImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0.0f)  // Evaluate your model in the Cloud console
                                   // to determine an appropriate value.
    .build()
val labeler = ImageLabeling.getClient(customImageLabelerOptions)

Si vous avez un modèle hébergé à distance, vous devrez 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 de modèle à l' aide du gestionnaire de modèle isModelDownloaded() méthode.

Bien que vous n'ayez qu'à le confirmer avant d'exécuter l'étiqueteuse, si vous avez à la fois un modèle hébergé à distance et un modèle fourni localement, il peut être judicieux d'effectuer cette vérification lors de l'instanciation de l'étiqueteuse d'image : créez une étiqueteuse à partir du modèle distant si il a été téléchargé, et à partir du modèle local sinon.

Java

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

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

Kotlin

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

Si vous n'avez qu'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 interface utilisateur) jusqu'à ce que vous confirmiez que le modèle a été téléchargé. Vous pouvez le faire en attachant un écouteur au gestionnaire de modèle download() méthode:

Java

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @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.
            }
        });

Kotlin

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

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

Ensuite, pour chaque image que vous souhaitez étiqueter, créer un InputImage objet à partir de votre image. L'étiqueteuse d'image fonctionne le plus rapide lorsque vous utilisez un Bitmap ou, si vous utilisez l'API camera2, un YUV_420_888 media.Image , qui sont recommandés lorsque cela est possible.

Vous pouvez créer un InputImage à partir de différentes sources, chacun est expliqué ci - dessous.

L' utilisation d' un media.Image

Pour créer un InputImage objet d'un media.Image objet, par exemple lorsque vous prenez une photo de la caméra d'un appareil, passez le media.Image objet et la rotation de l'image à InputImage.fromMediaImage() .

Si vous utilisez la CameraX bibliothèque, les OnImageCapturedListener et ImageAnalysis.Analyzer cours calculent la valeur de rotation pour vous.

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

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

Kotlin+KTX

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
            // ...
        }
    }
}

Si vous n'utilisez pas de bibliothèque de caméras qui vous donne 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 la caméra dans l'appareil :

Java

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

/**
 * 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, Context context)
        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);

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360;

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    int result;
    switch (rotationCompensation) {
        case 0:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            break;
        case 90:
            result = FirebaseVisionImageMetadata.ROTATION_90;
            break;
        case 180:
            result = FirebaseVisionImageMetadata.ROTATION_180;
            break;
        case 270:
            result = FirebaseVisionImageMetadata.ROTATION_270;
            break;
        default:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            Log.e(TAG, "Bad rotation value: " + rotationCompensation);
    }
    return result;
}

Kotlin+KTX

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 90)
    ORIENTATIONS.append(Surface.ROTATION_90, 0)
    ORIENTATIONS.append(Surface.ROTATION_180, 270)
    ORIENTATIONS.append(Surface.ROTATION_270, 180)
}
/**
 * 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, context: Context): 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)

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    val result: Int
    when (rotationCompensation) {
        0 -> result = FirebaseVisionImageMetadata.ROTATION_0
        90 -> result = FirebaseVisionImageMetadata.ROTATION_90
        180 -> result = FirebaseVisionImageMetadata.ROTATION_180
        270 -> result = FirebaseVisionImageMetadata.ROTATION_270
        else -> {
            result = FirebaseVisionImageMetadata.ROTATION_0
            Log.e(TAG, "Bad rotation value: $rotationCompensation")
        }
    }
    return result
}

Ensuite, passer le media.Image objet et la valeur du degré de rotation de InputImage.fromMediaImage() :

Java

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

Kotlin+KTX

val image = InputImage.fromMediaImage(mediaImage, rotation)

Utiliser un URI de fichier

Pour créer un InputImage objet à partir d' un fichier URI, passez le contexte de l' application et de l' URI de fichier InputImage.fromFilePath() . Ceci est utile lorsque vous utilisez une ACTION_GET_CONTENT intention de demander à l'utilisateur de sélectionner une image à partir de leur application Galerie.

Java

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

Kotlin+KTX

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

L' utilisation d' un ByteBuffer ou ByteArray

Pour créer un InputImage objet à partir d' un ByteBuffer ou un ByteArray , d' abord calculer le degré de rotation de l' image comme décrit précédemment pour media.Image entrée. Ensuite, créer le InputImage objet avec le tampon ou d'un tableau, ainsi que la hauteur de l' image, la largeur, le format codant pour la couleur, et le degré de rotation:

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);

Kotlin+KTX

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)

L' utilisation d' un Bitmap

Pour créer un InputImage objet d'un Bitmap objet, faire la déclaration suivante:

Java

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

Kotlin+KTX

val image = InputImage.fromBitmap(bitmap, 0)

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

3. Exécutez l'étiqueteuse d'images

Pour les objets étiquette dans une image, transmettre l' image de l' objet à la ImageLabeler de process() méthode.

Java

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
                // ...
            }
        });

Kotlin

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

4. Obtenir des informations sur les objets étiquetés

Si l'opération de marquage d'image réussit, une liste de ImageLabel objets est passé à l'auditeur de succès. Chaque ImageLabel objet représente quelque chose qui a été marqué dans l'image. Vous pouvez obtenir la description textuelle de chaque étiquette, le score de confiance de la correspondance et l'index de la correspondance. Par exemple:

Java

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

Kotlin

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

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

Si vous souhaitez étiqueter des images dans une application en temps réel, suivez ces instructions pour obtenir les meilleures fréquences d'images :
  • Throttle appelle l'étiqueteuse d'image. Si une nouvelle image vidéo devient disponible pendant que l'étiqueteuse d'image est en cours d'exécution, supprimez l'image. Voir la VisionProcessorBase classe dans l'exemple d' application de QuickStart pour un exemple.
  • Si vous utilisez la sortie de l'étiqueteuse d'image pour superposer des graphiques sur l'image d'entrée, obtenez d'abord le résultat, puis restituez l'image et superposez-la en une seule étape. Ce faisant, vous effectuez un rendu sur la surface d'affichage une seule fois pour chaque image d'entrée. Voir les CameraSourcePreview et GraphicOverlay classes dans l'exemple d' application de QuickStart pour un exemple.
  • Si vous utilisez l'API Camera2, de capturer des images dans ImageFormat.YUV_420_888 format.

    Si vous utilisez l'API de l' appareil plus ancien, de capturer des images dans ImageFormat.NV21 format.