Guide de classification d'images pour Python

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

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 pour le classificateur d'images fournit une implémentation complète de cette tâche en Python pour référence. Ce code vous aide à tester cette tâche et à commencer à 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'application exemple pour Raspberry Pi.

Configuration

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

Colis

La tâche de classification d'images utilise le package pip MediaPipe. Vous pouvez installer la dépendance avec ce qui suit:

$ python -m pip install mediapipe
``` ### Imports

Import the following classes to access the Image Classifier task functions:

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

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 un modèle, puis stockez-le dans un répertoire local. Vous pouvez utiliser le modèle EfficientNet-Lite0 recommandé.

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

Spécifiez le chemin d'accès au 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, 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, la liste d'autorisation de catégorie 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'images accepte trois types de données d'entrée: les images fixes, les fichiers vidéo et les flux vidéo en direct. 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.

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 propose les options de configuration suivantes pour les applications Python:

Préparer les 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 en direct à partir d'une webcam, vous pouvez utiliser une bibliothèque externe telle que OpenCV pour charger vos frames d'entrée en tant que tableaux numpy.

Les exemples suivants expliquent et montrent comment préparer les données pour le traitement 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 frame 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 :

• Lorsque vous exécutez le mode vidéo ou le mode de diffusion en direct, vous devez également fournir à la tâche de classification d'images le code temporel du frame d'entrée.
• Lorsqu'elle s'exécute dans le modèle d'image ou de 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.
• 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 classification 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.

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 classification d'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:

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 l'exemple de code.