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 lors de l'entraînement. Ces instructions vous expliquent comment utiliser le classificateur d'images avec Python.

Pour voir concrètement en quoi consiste cette tâche, consultez la page Web une démonstration. Pour plus d'informations sur les fonctionnalités, les modèles et les options de configuration 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 ce dans Python à titre de référence. Ce code vous aide à tester cette tâche et à obtenir vous avez commencé à créer votre propre classificateur d'images. Vous pouvez afficher, exécuter et modifier les Exemple de classificateur d'images du code en utilisant uniquement votre navigateur Web.

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

Configuration

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

Colis

Tâche de classificateur d'images dans le package pip mediapipe. Vous pouvez installer par 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 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 les recommandations efficaceNet-Lite0 dans un modèle de ML.

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 La fonction create_from_options 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, la liste d'autorisation des catégories et la liste de refus. 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 et fichiers vidéo et les flux vidéo en direct. Choisissez l'onglet correspondant au type de données d'entrée pour 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 le code exemple.

Options de configuration

Cette tâche comporte 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 mediapipe.Image. Si votre entrée est un fichier vidéo ou une diffusion en direct webcam, vous pouvez utiliser une bibliothèque externe comme OpenCV pour charger vos frames d'entrée au format Numpy ; tableaux.

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 de course les inférences. L'API Image Classifier renvoie les catégories possibles pour l'élément 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 :

• Lorsque vous êtes en mode vidéo ou flux en direct, vous devez également fournir à la tâche de classificateur d'images le code temporel de la trame d'entrée.
• Lors de l'exécution dans le modèle d'image ou de vidéo, la tâche de classification d'images bloquer le thread actuel jusqu'à ce qu'il ait fini de traiter l'image d'entrée ou cadre.
• 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 classification chaque fois qu'il se termine 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 une autre image, elle ignore pour la nouvelle trame d'entrée.

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

Gérer et afficher les résultats

Lors de l'exécution de l'inférence, la tâche de classification d'images renvoie une Un objet ImageClassifierResult contenant la liste des catégories possibles pour les objets dans l'image ou le cadre 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 la classification renvoyés par la tâche, consultez le code exemple pour en savoir plus.