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

La tâche de l'intégrateur d'images MediaPipe vous permet de convertir des données d'image en représentation numérique pour effectuer des tâches de traitement d'images liées au ML, comme comparer les de la similitude de deux images. Ces instructions vous expliquent comment utiliser 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 l'outil d'intégration 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 outil d'intégration d'images. Vous pouvez afficher, exécuter et modifier les Exemple d'outil d'intégration d'images du code en utilisant simplement votre navigateur Web avec Google Colab. Vous pouvez afficher le code source cet exemple sur GitHub

Configuration

Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement projets de code spécifiques pour utiliser l'outil d'intégration 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 d'intégration d'images dans le package pip mediapipe. Vous pouvez installer la dépendance par les éléments suivants:

$ python -m pip install mediapipe

Importations

Importez les classes suivantes pour accéder aux fonctions de la tâche de l'intégrateur d'images:

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

Modèle

La tâche de l'intégrateur 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 l'intégrateur 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 MobileNetV3 dans un modèle de ML.

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 La fonction create_from_options accepte les options de configuration pour définir l'intégrateur options. Pour plus d'informations sur les options de configuration, consultez la section Configuration Présentation.

La tâche de l'intégrateur 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
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 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.

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 les inférences. L'API Image Embedder renvoie les vecteurs de représentation vectorielle continue pour le l'image ou le 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 :

• Lorsque vous êtes en mode vidéo ou flux en direct, vous devez également fournir à la tâche de l'intégrateur d'images le code temporel de la trame d'entrée.
• Lors de l'exécution dans l'image ou le modèle vidéo, la tâche "Outil d'intégration d'images" bloquer le thread actuel jusqu'à ce qu'il ait fini de traiter l'image d'entrée ou cadre.
• Lors de l'exécution en mode de diffusion en direct, la tâche de l'intégrateur d'images ne bloque pas le thread actuel, mais renvoie immédiatement. Elle appellera son résultat avec le résultat de la représentation vectorielle continue chaque fois que le traitement d'une trame d'entrée. Si la fonction embedAsync est appelée lorsque l'intégrateur d'images est occupée à traiter une autre trame, la tâche ignore la nouvelle trame d'entrée.

Gérer et afficher les résultats

Lors de l'exécution de l'inférence, la tâche d'intégration d'images renvoie un ImageEmbedderResult qui contient 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:

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 fonction ImageEmbedder.cosine_similarity. Consultez le code suivant pour obtenir à titre d'exemple.

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