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

La tâche MediaPipe Image Embedder vous permet de convertir les données d'image en représentation numérique pour effectuer des tâches de traitement d'image 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 section Présentation.

Exemple de code

L'exemple de code pour Image Embedder 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 outil d'intégration d'images. Vous pouvez afficher, exécuter et modifier l'exemple de code de l'outil d'intégration d'images à l'aide de Google Colab et de votre navigateur Web. Vous pouvez consulter le code source de cet exemple sur GitHub.

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 Image Embedder. 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 d'intégration d'images utilise le package pip MediaPipe. Vous pouvez installer la dépendance avec les éléments suivants:

$ python -m pip install mediapipe

Importations

Importez les classes suivantes pour accéder aux fonctions de la tâche 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'encapsulation d'image 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 Image Embedder, 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 MobileNetV3 recommandé.

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

Spécifiez le chemin d'accès au 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 d'intégration. Pour en savoir plus sur les options de configuration, consultez la section Présentation de la configuration.

La tâche d'insertion 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
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 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.

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 d'encapsulation pour l'image ou le frame 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 :

• Lorsque vous exécutez le mode vidéo ou le mode diffusion en direct, vous devez également fournir à la tâche d'intégration d'images le code temporel du frame 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'il ait terminé le traitement de l'image ou du frame d'entrée.
• Lorsqu'elle s'exécute en mode diffusion en direct, la tâche d'intégration d'images ne bloque pas le thread en cours, mais renvoie immédiatement. Il appelle son écouteur de résultats avec le résultat d'encapsulation chaque fois qu'il a terminé le traitement d'un frame d'entrée. Si la fonction embedAsync est appelée lorsque la tâche 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 Image Embedder renvoie un objet ImageEmbedderResult 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:

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 encapsulant l'image suivante:

Vous pouvez comparer la similarité de deux représentations vectorielles continues à l'aide de la fonction ImageEmbedder.cosine_similarity. Pour en savoir plus, consultez le code suivant.

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