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 section Présentation.

Exemple de code

L'exemple de code MediaPipe Tasks est une implémentation simple d'un classificateur d'images pour Android. L'exemple utilise l'appareil photo d'un appareil Android physique pour classer des objets en continu, et utiliser des images et des vidéos provenant la galerie d'appareils pour classer les 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 pour le classificateur d'images est hébergé GitHub

Télécharger le code

Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple à 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 paiement creuse. Vous n'avez donc que les fichiers de l'application exemple 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 les Guide de configuration pour Android

Composants clés

Les fichiers suivants contiennent le code essentiel pour cette image Exemple d'application de classification:

• ImageClassifierHelper.kt : Il initialise le classificateur d'images, et gère le modèle et la délégation de votre choix.
• MainActivity.kt : Elle implémente l'application, y compris en appelant ImageClassificationHelper et ClassificationResultsAdapter
• ClassificationResultsAdapter.kt : Il 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 pour utiliser le classificateur d'images. Pour obtenir des informations générales sur configurer votre environnement de développement pour utiliser les tâches MediaPipe, y compris versions de la plate-forme requises, consultez la Guide de configuration pour Android

Dépendances

Le classificateur d'images utilise la bibliothèque com.google.mediapipe:tasks-vision. Ajouter au fichier build.gradle de votre Projet de développement d'applications 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 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

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

Dans Exemple de code pour le classificateur d'images le modèle est défini dans l'élément ImageClassifierHelper.kt. .

Créer la tâche

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

La tâche "Outil de classification d'images" accepte trois types de données d'entrée: images fixes, 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 lors de la création de 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 passer différents modes de traitement. L'approche rend le code de création de la tâche plus compliqué et peuvent ne pas être adaptés à votre cas d'utilisation. Ce code figure dans la fonction setupImageClassifier() de ImageClassifierHelper.kt .

Options de configuration

Cette tâche comporte 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 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 valeur. normalisation.

Vous devez convertir l'image ou le cadre d'entrée en com.google.mediapipe.framework.image.MPImage avant de le transmettre à 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 exemple de code pour le classificateur d'images, la préparation des données est gérée dans 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 :

• Lorsque vous êtes 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 classificateur d'images.
• Lors de l'exécution en mode image ou vidéo, la tâche "Outil de classification d'images" bloque le thread actuel jusqu'à ce qu'il ait fini de traiter l'image d'entrée ou cadre. Pour éviter de bloquer l'interface utilisateur, exécutez le traitement dans un thread d'arrière-plan.
• En mode de diffusion en direct, la tâche de classification d'images ne bloque pas le thread actuel, mais renvoie immédiatement. Elle appellera son résultat avec le résultat de la détection chaque fois que le traitement d'une trame d'entrée. Si la fonction classifyAsync est appelée lorsque le classificateur d'image est occupée à traiter une autre trame, la tâche ignore la nouvelle trame d'entrée.

Dans exemple de code pour le classificateur d'images, les fonctions classify sont définies dans 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 Exemple de code pour le classificateur d'images, la classe ClassificationResultsAdapter dans 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]
        }
    }
}