Guide sur l'intégration d'images pour Python

La tâche d'intégration d'images MediaPipe vous permet de convertir des données d'image en une représentation numérique pour effectuer des tâches de traitement d'images liées au ML, telles que la comparaison de la similarité de deux images. Ces instructions vous expliquent comment utiliser l'outil d'intégration d'images avec Python.

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 l'outil d'intégration 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 intégrateur d'images. Vous pouvez afficher, exécuter et modifier l'exemple de code de l'outil d'intégration d'images en utilisant simplement votre navigateur Web avec Google Colab. Vous pouvez afficher le code source de cet exemple sur GitHub.

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 de l'outil d'intégration 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 concernant les versions de la plate-forme, consultez le guide de configuration de Python.

Colis

Tâche d'intégration d'images au 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 l'outil d'intégration d'images:

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

Modèle

La tâche d'intégration 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 l'outil d'intégration 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 MobileNetV3 recommandé.

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

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

base_options = BaseOptions(model_asset_path=model_path)

Créer la tâche

Vous pouvez utiliser la fonction create_from_options pour créer la tâche. La fonction create_from_options accepte des options de configuration pour définir les options de l'outil d'intégration. Pour en savoir plus sur les options de configuration, consultez la section Présentation de la configuration.

La tâche d'intégration d'images est compatible avec 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
ImageEmbedder = mp.tasks.vision.ImageEmbedder
ImageEmbedderOptions = mp.tasks.vision.ImageEmbedderOptions
VisionRunningMode = mp.tasks.vision.RunningMode

options = ImageEmbedderOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.tflite'),
    quantize=True,
    running_mode=VisionRunningMode.IMAGE)

with ImageEmbedder.create_from_options(options) as embedder:
  # The embedder is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
ImageEmbedder = mp.tasks.vision.ImageEmbedder
ImageEmbedderOptions = mp.tasks.vision.ImageEmbedderOptions
VisionRunningMode = mp.tasks.vision.RunningMode

options = ImageEmbedderOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.tflite'),
    quantize=True,
    running_mode=VisionRunningMode.VIDEO)

with ImageEmbedder.create_from_options(options) as embedder:
  # The embedder is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
ImageEmbedderResult = mp.tasks.vision.ImageEmbedder.ImageEmbedderResult
ImageEmbedder = mp.tasks.vision.ImageEmbedder
ImageEmbedderOptions = mp.tasks.vision.ImageEmbedderOptions
VisionRunningMode = mp.tasks.vision.RunningMode

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

options = ImageEmbedderOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.tflite'),
    running_mode=VisionRunningMode.LIVE_STREAM,
    quantize=True,
    result_callback=print_result)

with ImageEmbedder.create_from_options(options) as embedder:
  # The embedder is initialized. Use it here.
  # ...
    

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

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 d'intégration correspondant à votre mode d'exécution pour déclencher des inférences. L'API Image Embedder renvoie les vecteurs de représentation vectorielle continue de l'image ou du cadre d'entrée.

# Perform image embedding on the provided single image.
embedding_result = embedder.embed(mp_image)
    

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

# Perform image embedding on the video frame.
embedding_result = embedder.embed_for_video(mp_image, frame_timestamp_ms)
    

# Send the latest frame to perform image embedding.
# Results are sent to the `result_callback` provided in the `ImageEmbedderOptions`.
embedder.embed_async(mp_image, frame_timestamp_ms)
    

Veuillez noter les points suivants :

• Lors de l'exécution en mode vidéo ou en mode de diffusion en direct, vous devez également fournir à la tâche d'intégration 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 d'intégration d'images bloque le thread actuel jusqu'à ce qu'elle ait fini de traiter l'image ou le cadre d'entrée.
• Lorsqu'elle est exécutée en mode diffusion en direct, la tâche d'intégration d'images ne bloque pas le thread actuel, mais est renvoyée immédiatement. Elle appelle son écouteur de résultat avec le résultat de la représentation vectorielle continue chaque fois qu'il a fini de traiter une trame d'entrée. Si la fonction embedAsync est appelée lorsque la tâche de l'outil d'intégration d'images est occupée à traiter un autre frame, la tâche ignore le nouveau frame d'entrée.

Gérer et afficher les résultats

Lors de l'exécution de l'inférence, la tâche de l'outil d'intégration d'images renvoie un objet ImageEmbedderResult contenant la liste des catégories possibles pour les objets dans l'image ou le cadre d'entrée.

Voici un exemple des données de sortie de cette tâche:

ImageEmbedderResult:
  Embedding #0 (sole embedding head):
    float_embedding: {0.0, 0.0, ..., 0.0, 1.0, 0.0, 0.0, 2.0}
    head_index: 0

Ce résultat a été obtenu en intégrant l'image suivante:

Vous pouvez comparer la similarité de deux représentations vectorielles continues à l'aide de la fonction ImageEmbedder.cosine_similarity. Consultez le code suivant pour obtenir un exemple.

# Compute cosine similarity.
similarity = ImageEmbedder.cosine_similarity(
  embedding_result.embeddings[0],
  other_embedding_result.embeddings[0])