Détection de points clés

La détection de points clés identifie et localise des points d'intérêt spécifiques au sein d'une image. Ces points clés, également appelés points de repère, représentent des caractéristiques significatives des objets, telles que les traits du visage ou les parties d'un objet. Ces modèles prennent une image en entrée et renvoient les sorties suivantes :

Points clés et scores : Points d'intérêt et leurs scores de confiance.
Descripteurs : une représentation de la région de l'image entourant chaque point clé, capturant sa texture, son gradient, son orientation et d'autres propriétés.

Dans ce guide, nous vous montrons comment extraire des points clés à partir d’images.

Pour ce tutoriel, nous utiliserons SuperPoint, un modèle de fondation pour la détection de points clés.

from transformers import AutoImageProcessor, SuperPointForKeypointDetection
processor = AutoImageProcessor.from_pretrained("magic-leap-community/superpoint")
model = SuperPointForKeypointDetection.from_pretrained("magic-leap-community/superpoint")

Testons le modèle sur les images ci-dessous.

import torch
from PIL import Image
import requests
import cv2


url_image_1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"
image_1 = Image.open(requests.get(url_image_1, stream=True).raw)
url_image_2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/cats.png"
image_2 = Image.open(requests.get(url_image_2, stream=True).raw)

images = [image_1, image_2]

Nous pouvons maintenant traiter nos entrées et effectuer l'inférence.

inputs = processor(images,return_tensors="pt").to(model.device, model.dtype)
outputs = model(**inputs)

La sortie du modèle contient des points clés relatifs, des descripteurs, des masques et des scores pour chaque élément du lot. Le masque met en évidence les zones de l'image où des points clés sont présents.

SuperPointKeypointDescriptionOutput(loss=None, keypoints=tensor([[[0.0437, 0.0167],
         [0.0688, 0.0167],
         [0.0172, 0.0188],
         ...,
         [0.5984, 0.9812],
         [0.6953, 0.9812]]]), 
         scores=tensor([[0.0056, 0.0053, 0.0079,  ..., 0.0125, 0.0539, 0.0377],
        [0.0206, 0.0058, 0.0065,  ..., 0.0000, 0.0000, 0.0000]],
       grad_fn=<CopySlices>), descriptors=tensor([[[-0.0807,  0.0114, -0.1210,  ..., -0.1122,  0.0899,  0.0357],
         [-0.0807,  0.0114, -0.1210,  ..., -0.1122,  0.0899,  0.0357],
         [-0.0807,  0.0114, -0.1210,  ..., -0.1122,  0.0899,  0.0357],
         ...],
       grad_fn=<CopySlices>), mask=tensor([[1, 1, 1,  ..., 1, 1, 1],
        [1, 1, 1,  ..., 0, 0, 0]], dtype=torch.int32), hidden_states=None)

Pour tracer les points clés réels dans l'image, il est nécessaire de post-traiter la sortie. Pour ce faire, il faut transmettre les dimensions réelles de l'image à post_process_keypoint_detection en même temps que les sorties.

image_sizes = [(image.size[1], image.size[0]) for image in images]
outputs = processor.post_process_keypoint_detection(outputs, image_sizes)

Les sorties sont désormais une liste de dictionnaires où chaque dictionnaire est une sortie traitée de points clés, de scores et de descripteurs.

[{'keypoints': tensor([[ 226,   57],
          [ 356,   57],
          [  89,   64],
          ...,
          [3604, 3391]], dtype=torch.int32),
  'scores': tensor([0.0056, 0.0053, ...], grad_fn=<IndexBackward0>),
  'descriptors': tensor([[-0.0807,  0.0114, -0.1210,  ..., -0.1122,  0.0899,  0.0357],
          [-0.0807,  0.0114, -0.1210,  ..., -0.1122,  0.0899,  0.0357]],
         grad_fn=<IndexBackward0>)},
    {'keypoints': tensor([[ 46,   6],
          [ 78,   6],
          [422,   6],
          [206, 404]], dtype=torch.int32),
  'scores': tensor([0.0206, 0.0058, 0.0065, 0.0053, 0.0070, ...,grad_fn=<IndexBackward0>),
  'descriptors': tensor([[-0.0525,  0.0726,  0.0270,  ...,  0.0389, -0.0189, -0.0211],
          [-0.0525,  0.0726,  0.0270,  ...,  0.0389, -0.0189, -0.0211]}]

Nous pouvons les utiliser pour tracer les points clés.

import matplotlib.pyplot as plt
import torch

for i in range(len(images)):
  keypoints = outputs[i]["keypoints"]
  scores = outputs[i]["scores"]
  descriptors = outputs[i]["descriptors"]
  keypoints = outputs[i]["keypoints"].detach().numpy()
  scores = outputs[i]["scores"].detach().numpy()
  image = images[i]
  image_width, image_height = image.size

  plt.axis('off')
  plt.imshow(image)
  plt.scatter(
      keypoints[:, 0],
      keypoints[:, 1],
      s=scores * 100,
      c='cyan',
      alpha=0.4
  )
  plt.show()

Vous pouvez voir les résultats ci-dessous.

Update on GitHub

Transformers

Détection de points clés