Appariement de points clés

La correspondance de points clés consiste à associer différents points d'intérêt appartenant à un même objet apparaissant dans deux images différentes. La plupart des correspondants de points clés modernes prennent des images en entrée et produisent les éléments suivants :

Coordonnées des points clés (x, y) : correspondance un-à-un des coordonnées de pixels entre la première et la deuxième image à l'aide de deux listes. Chaque point clé à un index donné dans la première liste est apparié au point clé au même index dans la deuxième liste.
Notes d'adéquation : Notes attribuées aux correspondances de points clés.

Dans ce tutoriel, vous allez extraire des correspondances de points clés avec le modèle EfficientLoFTR entraîné avec le framework MatchAnything, puis affiner ces correspondances. Ce modèle ne compte que 16M de paramètres et peut être exécuté sur un CPU. Vous utiliserez la classe AutoModelForKeypointMatching.

from transformers import AutoImageProcessor, AutoModelForKeypointMatching
import torch

processor = AutoImageProcessor.from_pretrained("zju-community/matchanything_eloftr")
model = AutoModelForKeypointMatching.from_pretrained("zju-community/matchanything_eloftr")

Chargez deux images qui présentent le même objet d'intérêt. La deuxième photo est prise une seconde plus tard, ses couleurs sont modifiées, et elle est davantage recadrée et tournée.

from transformers.image_utils import load_image
image1 = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg")
image2 = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee_edited.jpg")

images = [image1, image2]

Nous pouvons passer les images au processeur et effectuer l'inférence.

inputs = processor(images, return_tensors="pt")
with torch.no_grad():
    outputs = model(**inputs)

Nous pouvons post-traiter les sorties. Le paramètre threshold est utilisé pour affiner le bruit (seuils de confiance plus bas) dans les correspondances de sortie.

image_sizes = [[(image.height, image.width) for image in images]]

outputs = processor.post_process_keypoint_matching(outputs, image_sizes, threshold=0.2)
print(outputs)

Voici les sorties.

[{'keypoints0': tensor([[4514,  550],
          [4813,  683],
          [1972, 1547],
          ...
          [3916, 3408]], dtype=torch.int32),
  'keypoints1': tensor([[2280,  463],
          [2378,  613],
          [2231,  887],
          ...
          [1521, 2560]], dtype=torch.int32),
  'matching_scores': tensor([0.2189, 0.2073, 0.2414, ...
    ])}]

Nous avons réduit la sortie, mais il y a 401 correspondances !

len(outputs[0]["keypoints0"])
# 401

Nous pouvons les visualiser à l’aide de la méthode visualize_keypoint_matching() du processeur.

plot_images = processor.visualize_keypoint_matching(images, outputs)
plot_images

Matched Image

Facultativement, vous pouvez utiliser l’API Pipeline et définir la tâche sur keypoint-matching.

from transformers import pipeline 

image_1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"
image_2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee_edited.jpg"

pipe = pipeline("keypoint-matching", model="zju-community/matchanything_eloftr")
pipe([image_1, image_2])

La sortie ressemble à ce qui suit.

[{'keypoint_image_0': {'x': 2444, 'y': 2869},
  'keypoint_image_1': {'x': 837, 'y': 1500},
  'score': 0.9756593704223633},
 {'keypoint_image_0': {'x': 1248, 'y': 2819},
  'keypoint_image_1': {'x': 862, 'y': 866},
  'score': 0.9735618829727173},
 {'keypoint_image_0': {'x': 1547, 'y': 3317},
  'keypoint_image_1': {'x': 1436, 'y': 1500},
  ...
 }
]

Update on GitHub

Transformers

Appariement de points clés