Guide de classification d'images pour Python

La tâche de classificateur d'images MediaPipe vous permet d'effectuer une classification d'images. Vous pouvez utiliser cette tâche pour identifier ce que représente une image 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 Python.

Pour voir concrètement cette tâche, consultez 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 pour le classificateur d'images fournit une implémentation complète de cette tâche en Python à titre de référence. Ce code vous aide à tester cette tâche et à créer votre propre classificateur d'images. Vous pouvez afficher, exécuter et modifier l'exemple de code du classificateur d'images à l'aide de votre navigateur Web.

Si vous implémentez le classificateur d'images pour Raspberry Pi, consultez l'exemple d'application pour Raspberry Pi.

Préparation

Cette section décrit les étapes clés de la configuration de votre environnement de développement et de vos projets de code spécifiquement pour l'utilisation du 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 sur les exigences de version de la plate-forme, consultez le guide de configuration pour Python.

Colis

La tâche de classificateur d'images dans le package pip mediapipe Vous pouvez installer la dépendance avec la commande suivante:

$ python -m pip install mediapipe

Importations

Importez les classes suivantes pour accéder aux fonctions des tâches de classificateur d'images:

import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision

Modèle

La tâche de classificateur 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 un modèle, puis stockez-le dans un répertoire local. Vous pouvez utiliser le modèle EffectiveNet-Lite0 recommandé.

model_path = '/absolute/path/to/efficientnet_lite0_int8_2.tflite'

Spécifiez le chemin d'accès du modèle dans le paramètre "Nom du modèle", comme indiqué ci-dessous:

base_options = BaseOptions(model_asset_path=model_path)

Créer la tâche

Utilisez la fonction create_from_options pour créer la tâche. La fonction create_from_options accepte des options de configuration telles que le mode d'exécution, les paramètres régionaux des noms à afficher, le nombre maximal de résultats, le seuil de confiance, la liste d'autorisation de catégories et la liste de refus. Pour en savoir plus sur les options de configuration, consultez la section Présentation de la configuration.

La tâche de classification d'image accepte trois types de données d'entrée: les images fixes, les fichiers vidéo et les flux vidéo en direct. Choisissez l'onglet correspondant à votre type de données d'entrée pour voir comment créer la tâche et exécuter l'inférence.

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
ImageClassifier = mp.tasks.vision.ImageClassifier
ImageClassifierOptions = mp.tasks.vision.ImageClassifierOptions
VisionRunningMode = mp.tasks.vision.RunningMode

options = ImageClassifierOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.tflite'),
    max_results=5,
    running_mode=VisionRunningMode.IMAGE)

with ImageClassifier.create_from_options(options) as classifier:
  # The classifier is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
ImageClassifier = mp.tasks.vision.ImageClassifier
ImageClassifierOptions = mp.tasks.vision.ImageClassifierOptions
VisionRunningMode = mp.tasks.vision.RunningMode

options = ImageClassifierOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.tflite'),
    max_results=5,
    running_mode=VisionRunningMode.VIDEO)

with ImageClassifier.create_from_options(options) as classifier:
  # The classifier is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
ImageClassifierResult = mp.tasks.vision.ImageClassifier.ImageClassifierResult
ImageClassifier = mp.tasks.vision.ImageClassifier
ImageClassifierOptions = mp.tasks.vision.ImageClassifierOptions
VisionRunningMode = mp.tasks.vision.RunningMode

def print_result(result: ImageClassifierResult, output_image: mp.Image, timestamp_ms: int):
    print('ImageClassifierResult result: {}'.format(result))

options = ImageClassifierOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.tflite'),
    running_mode=VisionRunningMode.LIVE_STREAM,
    max_results=5,
    result_callback=print_result)

with ImageClassifier.create_from_options(options) as classifier:
  # The classifier is initialized. Use it here.
  # ...
    

Pour obtenir un exemple complet de création d'un classificateur d'images à utiliser avec une image, consultez l'exemple de code.

Options de configuration

Cette tâche dispose des options de configuration suivantes pour les applications Python:

Préparation des données

Préparez votre entrée en tant que fichier image ou tableau Numpy, puis convertissez-la en objet mediapipe.Image. Si votre entrée est un fichier vidéo ou un flux vidéo en direct à partir d'une webcam, vous pouvez utiliser une bibliothèque externe telle que OpenCV pour charger vos images d'entrée sous forme de tableaux Numpy.

Les exemples suivants expliquent et montrent comment préparer les données à traiter pour chacun des types de données disponibles.

import mediapipe as mp

# Load the input image from an image file.
mp_image = mp.Image.create_from_file('/path/to/image')

# Load the input image from a numpy array.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_image)
    

import mediapipe as mp

# Use OpenCV’s VideoCapture to load the input video.

# Load the frame rate of the video using OpenCV’s CV_CAP_PROP_FPS
# You’ll need it to calculate the timestamp for each frame.

# Loop through each frame in the video using VideoCapture#read()

# Convert the frame received from OpenCV to a MediaPipe’s Image object.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_frame_from_opencv)
    

import mediapipe as mp

# Use OpenCV’s VideoCapture to start capturing from the webcam.

# Create a loop to read the latest frame from the camera using VideoCapture#read()

# Convert the frame received from OpenCV to a MediaPipe’s Image object.
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_frame_from_opencv)
    

Exécuter la tâche

Vous pouvez appeler la fonction de classification 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.

# Perform image classification on the provided single image.
classification_result = classifier.classify(mp_image)
    

# Calculate the timestamp of the current frame
frame_timestamp_ms = 1000 * frame_index / video_file_fps

# Perform image classification on the video frame.
classification_result = classifier.classify_for_video(mp_image, frame_timestamp_ms)
    

# Send the latest frame to perform image classification.
# Results are sent to the `result_callback` provided in the `ImageClassifierOptions`.
classifier.classify_async(mp_image, frame_timestamp_ms)
    

Veuillez noter les points suivants :

• Lors de l'exécution en mode vidéo ou en mode flux en direct, vous devez également fournir à la tâche de classificateur d'images l'horodatage de l'image d'entrée.
• Lors de l'exécution dans le modèle d'image ou de vidéo, la tâche de classificateur d'images bloque le thread actuel jusqu'à ce qu'elle ait fini de traiter l'image ou l'image d'entrée.
• Lors de l'exécution en mode de diffusion en direct, la tâche de classificateur d'images ne bloque pas le thread actuel, mais est renvoyée immédiatement. Il appelle son écouteur de résultat avec le résultat de la classification chaque fois qu'il a fini de traiter une trame d'entrée. Si la fonction classifyAsync est appelée lorsque la tâche de classificateur d'images est occupée à traiter un autre frame, la tâche ignore le nouveau cadre d'entrée.

Pour obtenir un exemple complet de création d'un classificateur d'images à utiliser avec une image, consultez l'exemple de code.

Gérer et afficher les résultats

Lors de l'exécution de l'inférence, la tâche de classificateur d'images renvoie un objet ImageClassifierResult contenant la liste des catégories possibles pour les objets de l'image ou du cadre 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

Vous avez obtenu ce résultat en exécutant le classificateur d'oiseaux sur:

L'exemple de code du classificateur d'images montre comment afficher les résultats de classification renvoyés par la tâche. Pour en savoir plus, consultez cet exemple de code.