Guide de classification d'images pour Python

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

Vous pouvez voir cette tâche en action dans 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 dans Python à titre de référence. Ce code vous permet de tester cette tâche et de commencer à créer votre propre classificateur d'images. Vous pouvez afficher, exécuter et modifier l'exemple de code du classificateur d'images en utilisant uniquement 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 à 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 l'utilisation des tâches MediaPipe, y compris les exigences concernant les versions de la plate-forme, consultez le guide de configuration pour Python.

Colis

Tâche de classificateur d'images dans le package pip mediapipe. Vous pouvez installer la dépendance avec les éléments suivants:

$ 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 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 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, la liste d'autorisation des catégories et la liste de refus. 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. 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.

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'image à utiliser avec une image, consultez l'exemple de code.

Options de configuration

Cette tâche comporte les 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 en direct à partir d'une webcam, vous pouvez utiliser une bibliothèque externe telle que OpenCV pour charger vos images d'entrée en tant que 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 flux en direct, vous devez également fournir à la tâche de classificateur d'images l'horodatage de la trame d'entrée.
• Lors de l'exécution dans le modèle d'image ou vidéo, la tâche de classificateur d'image bloque le thread actuel jusqu'à ce qu'il 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 classification d'images ne bloque pas le thread actuel, mais renvoie immédiatement un résultat. Il appelle l'écouteur des résultats avec le résultat de la classification 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.

Pour obtenir un exemple complet de création d'un classificateur d'image à 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 qui contient la liste des catégories possibles pour les objets se trouvant 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:

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