Guide de classification d'images pour Android

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

Pour voir cette tâche en action, 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 section 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 en continu les objets. Il peut également utiliser des images et des vidéos de la galerie de l'appareil pour classer de manière statique les objets.

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 qu'elle utilise un "checkout sparse" afin de n'avoir que les fichiers de l'application exemple de classification des 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 de cet exemple d'application de classification d'images:

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

Configuration

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 utiliser les 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'application Android. Importez les dépendances requises avec le 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 de la tâche.

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 référencé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 des 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égorie. Pour en savoir plus sur les options de configuration, consultez la section Présentation de la configuration.

La tâche de classification d'images accepte trois types de données d'entrée: les images fixes, les fichiers vidéo et les 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. Sélectionnez 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'implémentation de l'exemple de code du classificateur d'images permet à l'utilisateur de basculer entre les modes de traitement. Cette approche rend le code de création de tâche plus complexe et n'est peut-être pas 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 propose les options de configuration suivantes pour les applications Android:

Préparer les données

Le classificateur d'images fonctionne avec les images, les fichiers vidéo et les vidéos 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 frame d'entrée en objet com.google.mediapipe.framework.image.MPImage avant de le transmettre au classificateur 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 du classificateur 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 frame 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 :

• Lorsque vous exécutez le mode vidéo ou le mode de diffusion en direct, vous devez également fournir le code temporel du frame d'entrée à la tâche de classification des images.
• Lorsqu'elle s'exécute en mode image ou vidéo, la tâche de classification d'images bloque le thread actuel jusqu'à ce qu'elle ait terminé de traiter l'image ou le frame d'entrée. Pour éviter de bloquer l'interface utilisateur, exécutez le traitement dans un thread en arrière-plan.
• Lorsqu'elle s'exécute en mode diffusion en direct, la tâche de classification des images ne bloque pas le thread actuel, mais renvoie immédiatement. Il appelle son écouteur de résultats avec le résultat de la détection chaque fois qu'il a terminé le traitement d'un frame d'entrée. Si la fonction classifyAsync est appelée lorsque la tâche de classification des images est occupée à traiter un autre frame, la tâche ignore le nouveau frame 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 des images renvoie un objet ImageClassifierResult contenant la liste des catégories possibles pour les objets de l'image ou du frame d'entrée.

Voici un exemple des 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]
        }
    }
}