Guide de classification d'images pour Android

La tâche de classification d'images MediaPipe vous permet d'effectuer une classification sur des images. Vous pouvez utiliser cette tâche pour identifier ce qu'une image représente dans un ensemble de catégories définies au moment de l'entraînement. Ces instructions vous expliquent comment utiliser le classificateur d'images avec les applications Android. L'exemple de code décrit dans ces instructions est disponible sur GitHub.

Pour voir concrètement cette tâche, regardez la démonstration Web. Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la présentation.

Exemple de code

L'exemple de code MediaPipe Tasks est une implémentation simple d'une application de classification d'images pour Android. L'exemple utilise l'appareil photo d'un appareil Android physique pour classer des objets en continu, et peut également utiliser des images et des vidéos de la galerie de l'appareil pour classer des objets de manière statique.

Vous pouvez utiliser l'application comme point de départ pour votre propre application Android ou vous y référer lorsque vous modifiez une application existante. L'exemple de code du classificateur d'images est hébergé sur GitHub.

Télécharger le code

Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple de code à l'aide de l'outil de ligne de commande git.

Pour télécharger l'exemple de code:

1. Clonez le dépôt git à l'aide de la commande suivante :

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Vous pouvez éventuellement configurer votre instance Git pour utiliser le processus de paiement creuse afin de ne disposer que des fichiers de l'exemple d'application de classificateur d'images :

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/image_classification/android
   

Après avoir créé une version locale de l'exemple de code, vous pouvez importer le projet dans Android Studio et exécuter l'application. Pour obtenir des instructions, consultez le guide de configuration pour Android.

Composants clés

Les fichiers suivants contiennent le code essentiel pour cet exemple d'application de classification d'images:

• ImageClassifierHelper.kt : initialise le classificateur d'images, et gère la sélection du modèle et de la délégation.
• MainActivity.kt : met en œuvre l'application, y compris en appelant ImageClassificationHelper et ClassificationResultsAdapter.
• ClassificationResultsAdapter.kt : gère et met en forme les résultats.

Préparation

Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement et vos projets de code afin d'utiliser le classificateur d'images. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour l'utilisation des tâches MediaPipe, y compris les exigences concernant les versions de la plate-forme, consultez le guide de configuration pour Android.

Dépendances

Le classificateur d'images utilise la bibliothèque com.google.mediapipe:tasks-vision. Ajoutez cette dépendance au fichier build.gradle de votre projet de développement d'applications Android. Importez les dépendances requises à l'aide du code suivant:

dependencies {
    ...
    implementation 'com.google.mediapipe:tasks-vision:latest.release'
}

Modèle

La tâche de classification d'images MediaPipe nécessite un modèle entraîné compatible avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour le classificateur d'images, consultez la section Modèles de la présentation des tâches.

Sélectionnez et téléchargez le modèle, puis stockez-le dans le répertoire de votre projet:

<dev-project-root>/src/main/assets

Utilisez la méthode BaseOptions.Builder.setModelAssetPath() pour spécifier le chemin d'accès utilisé par le modèle. Cette méthode est mentionnée dans l'exemple de code de la section suivante.

Dans l'exemple de code du classificateur d'images, le modèle est défini dans le fichier ImageClassifierHelper.kt.

Créer la tâche

Vous pouvez utiliser la fonction createFromOptions pour créer la tâche. La fonction createFromOptions accepte les options de configuration, y compris le mode d'exécution, les paramètres régionaux des noms à afficher, le nombre maximal de résultats, le seuil de confiance et une liste d'autorisation ou de refus de catégories. Pour en savoir plus sur les options de configuration, consultez la page Présentation de la configuration.

La tâche de classification d'images accepte trois types de données d'entrée: images fixes, fichiers vidéo et flux vidéo en direct. Vous devez spécifier le mode d'exécution correspondant à votre type de données d'entrée lorsque vous créez la tâche. Choisissez l'onglet correspondant à votre type de données d'entrée pour découvrir comment créer la tâche et exécuter l'inférence.

ImageClassifierOptions options =
  ImageClassifierOptions.builder()
    .setBaseOptions(
      BaseOptions.builder().setModelAssetPath("model.tflite").build())
    .setRunningMode(RunningMode.IMAGE)
    .setMaxResults(5)
    .build();
imageClassifier = ImageClassifier.createFromOptions(context, options);
    

ImageClassifierOptions options =
  ImageClassifierOptions.builder()
    .setBaseOptions(
      BaseOptions.builder().setModelAssetPath("model.tflite").build())
    .setRunningMode(RunningMode.VIDEO)
    .setMaxResults(5)
    .build();
imageClassifier = ImageClassifier.createFromOptions(context, options);
    

ImageClassifierOptions options =
  ImageClassifierOptions.builder()
    .setBaseOptions(
      BaseOptions.builder().setModelAssetPath("model.tflite").build())
    .setRunningMode(RunningMode.LIVE_STREAM)
    .setMaxResults(5)
    .setResultListener((result, inputImage) -> {
         // Process the classification result here.
    })
    .setErrorListener((result, inputImage) -> {
         // Process the classification errors here.
    })
    .build()
imageClassifier = ImageClassifier.createFromOptions(context, options)
    

L'exemple d'implémentation de code pour le classificateur d'images permet à l'utilisateur de basculer entre les modes de traitement. Cette approche complique le code de création de la tâche et peut ne pas être adaptée à votre cas d'utilisation. Vous pouvez voir ce code dans la fonction setupImageClassifier() du fichier ImageClassifierHelper.kt.

Options de configuration

Cette tâche comporte les options de configuration suivantes pour les applications Android:

Préparation des données

Le classificateur d'images fonctionne avec les images, les fichiers vidéo et les flux vidéo en direct. La tâche gère le prétraitement de l'entrée des données, y compris le redimensionnement, la rotation et la normalisation des valeurs.

Vous devez convertir l'image ou le cadre d'entrée en objet com.google.mediapipe.framework.image.MPImage avant de la transmettre à l'outil de classification d'images.

import com.google.mediapipe.framework.image.BitmapImageBuilder;
import com.google.mediapipe.framework.image.MPImage;

// Load an image on the user’s device as a Bitmap object using BitmapFactory.

// Convert an Android’s Bitmap object to a MediaPipe’s Image object.
Image mpImage = new BitmapImageBuilder(bitmap).build();
    

import com.google.mediapipe.framework.image.BitmapImageBuilder;
import com.google.mediapipe.framework.image.MPImage;

// Load a video file on the user's device using MediaMetadataRetriever

// From the video’s metadata, load the METADATA_KEY_DURATION and
// METADATA_KEY_VIDEO_FRAME_COUNT value. You’ll need them
// to calculate the timestamp of each frame later.

// Loop through the video and load each frame as a Bitmap object.

// Convert the Android’s Bitmap object to a MediaPipe’s Image object.
Image mpImage = new BitmapImageBuilder(frame).build();
    

import com.google.mediapipe.framework.image.MediaImageBuilder;
import com.google.mediapipe.framework.image.MPImage;

// Create a CameraX’s ImageAnalysis to continuously receive frames 
// from the device’s camera. Configure it to output frames in RGBA_8888
// format to match with what is required by the model.

// For each Android’s ImageProxy object received from the ImageAnalysis, 
// extract the encapsulated Android’s Image object and convert it to 
// a MediaPipe’s Image object.
android.media.Image mediaImage = imageProxy.getImage()
Image mpImage = new MediaImageBuilder(mediaImage).build();
    

Dans l'exemple de code de l'outil de classification d'images, la préparation des données est gérée dans le fichier ImageClassifierHelper.kt.

Exécuter la tâche

Vous pouvez appeler la fonction classify correspondant à votre mode d'exécution pour déclencher des inférences. L'API Image Classifier renvoie les catégories possibles pour l'objet dans l'image ou le cadre d'entrée.

ImageClassifierResult classifierResult = imageClassifier.classify(image);
    

// Calculate the timestamp in milliseconds of the current frame.
long frame_timestamp_ms = 1000 * video_duration * frame_index / frame_count;

// Run inference on the frame.
ImageClassifierResult classifierResult =
    imageClassifier.classifyForVideo(image, frameTimestampMs);
    

// Run inference on the frame. The classifications results will be available 
// via the `resultListener` provided in the `ImageClassifierOptions` when 
// the image classifier was created.
imageClassifier.classifyAsync(image, frameTimestampMs);
    

Veuillez noter les points suivants :

• Lors de l'exécution en mode vidéo ou flux en direct, vous devez également fournir le code temporel de la trame d'entrée à la tâche de classification d'images.
• Lors de l'exécution en mode image ou vidéo, la tâche de classification d'image bloque le thread actuel jusqu'à ce qu'il ait fini de traiter l'image ou l'image d'entrée. Pour éviter de bloquer l'interface utilisateur, exécutez le traitement dans un thread d'arrière-plan.
• Lors de l'exécution en mode de diffusion en direct, la tâche de classification d'images ne bloque pas le thread actuel, mais renvoie immédiatement un résultat. Il appelle l'écouteur de résultats avec le résultat de la détection chaque fois qu'il a terminé le traitement d'une trame d'entrée. Si la fonction classifyAsync est appelée lorsque la tâche de classification d'images est occupée à traiter une autre image, la tâche ignore la nouvelle trame d'entrée.

Dans l'exemple de code du classificateur d'images, les fonctions classify sont définies dans le fichier ImageClassifierHelper.kt.

Gérer et afficher les résultats

Lors de l'exécution de l'inférence, la tâche de classification d'images renvoie un objet ImageClassifierResult qui contient la liste des catégories possibles pour les objets dans l'image ou la trame d'entrée.

Voici un exemple de données de sortie de cette tâche:

ImageClassifierResult:
 Classifications #0 (single classification head):
  head index: 0
  category #0:
   category name: "/m/01bwb9"
   display name: "Passer domesticus"
   score: 0.91406
   index: 671
  category #1:
   category name: "/m/01bwbt"
   display name: "Passer montanus"
   score: 0.00391
   index: 670

Ce résultat a été obtenu en exécutant le classificateur d'oiseaux sur:

Dans l'exemple de code du classificateur d'images, la classe ClassificationResultsAdapter du fichier ClassificationResultsAdapter.kt gère les résultats:

fun updateResults(imageClassifierResult: ImageClassifierResult? = null) {
    categories = MutableList(adapterSize) { null }
    if (imageClassifierResult != null) {
        val sortedCategories = imageClassifierResult.classificationResult()
            .classifications()[0].categories().sortedBy { it.index() }
        val min = kotlin.math.min(sortedCategories.size, categories.size)
        for (i in 0 until min) {
            categories[i] = sortedCategories[i]
        }
    }
}