# SuperGlue

[SuperGlue](https://huggingface.co/papers/1911.11763) est un réseau de neurones qui associe deux ensembles de caractéristiques locales en trouvant simultanément les correspondances et en rejetant les points non appairables. Les affectations sont estimées en résolvant un problème de transport optimal différentiable, dont les coûts sont prédits par un réseau de neurones à graphes. SuperGlue introduit un mécanisme flexible d'agrégation de contexte basé sur l'attention, lui permettant de raisonner conjointement sur la scène 3D sous-jacente et sur les affectations de caractéristiques. Associé au [modèle SuperPoint](https://huggingface.co/magic-leap-community/superpoint), il peut être utilisé pour appairer deux images et estimer la pose entre elles. Ce modèle est utile pour des tâches telles que l'appairage d'images, l'estimation d'homographie, etc.

Vous pouvez trouver tous les points de contrôle originaux de SuperGlue sous l’organisation [Magic Leap Community](https://huggingface.co/magic-leap-community).

> [!TIP]
> Ce modèle a été contribué par [stevenbucaille](https://huggingface.co/stevenbucaille).
>
> Cliquez sur les modèles SuperGlue dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer SuperGlue à différentes tâches de vision par ordinateur.

L'exemple ci-dessous montre comment appairer les points clés entre deux images avec [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline) ou la classe [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

keypoint_matcher = pipeline(task="keypoint-matching", model="magic-leap-community/superglue_outdoor")

url_0 = "https://raw.githubusercontent.com/magicleap/SuperGluePretrainedNetwork/refs/heads/master/assets/phototourism_sample_images/united_states_capitol_98169888_3347710852.jpg"
url_1 = "https://raw.githubusercontent.com/magicleap/SuperGluePretrainedNetwork/refs/heads/master/assets/phototourism_sample_images/united_states_capitol_26757027_6717084061.jpg"

results = keypoint_matcher([url_0, url_1], threshold=0.9)
print(results[0])
# {'keypoint_image_0': {'x': ..., 'y': ...}, 'keypoint_image_1': {'x': ..., 'y': ...}, 'score': ...}
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModel

url_image1 = "https://raw.githubusercontent.com/magicleap/SuperGluePretrainedNetwork/refs/heads/master/assets/phototourism_sample_images/united_states_capitol_98169888_3347710852.jpg"
image1 = Image.open(requests.get(url_image1, stream=True).raw)
url_image2 = "https://raw.githubusercontent.com/magicleap/SuperGluePretrainedNetwork/refs/heads/master/assets/phototourism_sample_images/united_states_capitol_26757027_6717084061.jpg"
image2 = Image.open(requests.get(url_image2, stream=True).raw)

images = [image1, image2]

processor = AutoImageProcessor.from_pretrained("magic-leap-community/superglue_outdoor")
model = AutoModel.from_pretrained("magic-leap-community/superglue_outdoor", device_map="auto")

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

# Post-process to get keypoints and matches
image_sizes = [[(image.height, image.width) for image in images]]
processed_outputs = processor.post_process_keypoint_matching(outputs, image_sizes, threshold=0.2)
```

## Notes

- SuperGlue effectue l'appariement de caractéristiques entre deux images simultanément, nécessitant des paires d'images en entrée.

    ```python
    from transformers import AutoImageProcessor, AutoModel
    import torch
    from PIL import Image
    import requests

    processor = AutoImageProcessor.from_pretrained("magic-leap-community/superglue_outdoor")
    model = AutoModel.from_pretrained("magic-leap-community/superglue_outdoor", device_map="auto")

    # SuperGlue requires pairs of images
    images = [image1, image2]
    inputs = processor(images, return_tensors="pt").to(model.device)
    with torch.inference_mode():
        outputs = model(**inputs)

    # Extract matching information
    keypoints0 = outputs.keypoints0  # Keypoints in first image
    keypoints1 = outputs.keypoints1  # Keypoints in second image
    matches = outputs.matches        # Matching indices
    matching_scores = outputs.matching_scores  # Confidence scores
    ```

- Le modèle produit des indices correspondants, des points clés et des scores de confiance pour chaque correspondance.
- Pour une meilleure visualisation et analyse, utilisez la méthode [SuperGlueImageProcessor.post_process_keypoint_matching()](/docs/transformers/main/fr/model_doc/superglue#transformers.SuperGlueImageProcessor.post_process_keypoint_matching) pour obtenir les correspondances dans un format plus lisible.

    ```py
    # Process outputs for visualization
    image_sizes = [[(image.height, image.width) for image in images]]
    processed_outputs = processor.post_process_keypoint_matching(outputs, image_sizes, threshold=0.2)

    for i, output in enumerate(processed_outputs):
        print(f"For the image pair {i}")
        for keypoint0, keypoint1, matching_score in zip(
                output["keypoints0"], output["keypoints1"], output["matching_scores"]
        ):
            print(f"Keypoint at {keypoint0.numpy()} matches with keypoint at {keypoint1.numpy()} with score {matching_score}")
    ```

- Visualisez les correspondances entre les images à l'aide de la fonctionnalité de tracé intégrée.

    ```py
    # Easy visualization using the built-in plotting method
    processor.visualize_keypoint_matching(images, processed_outputs)
    ```

    

## Ressources

- Reportez-vous au [dépôt SuperGlue original](https://github.com/magicleap/SuperGluePretrainedNetwork) pour plus d’exemples et de détails d’implémentation.

## SuperGlueConfig[[transformers.SuperGlueConfig]]

#### transformers.SuperGlueConfig[[transformers.SuperGlueConfig]]

```python
transformers.SuperGlueConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, keypoint_detector_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_size: int = 256, keypoint_encoder_sizes: list[int] | None = None, gnn_layers_types: list[str] | None = None, num_attention_heads: int = 4, sinkhorn_iterations: int = 100, matching_threshold: float = 0.0, initializer_range: float = 0.02, is_decoder: bool = False, attention_probs_dropout_prob: int | float = 0.0)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/configuration_superglue.py#L24)

**Paramètres :**

keypoint_detector_config (`Union[AutoConfig, dict]`,  *facultatif*, par défaut `SuperPointConfig`) : L'objet de configuration ou le dictionnaire du détecteur de points clés.

hidden_size (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées.

keypoint_encoder_sizes (`list[int]`, *facultatif*, par défaut `[32, 64, 128, 256]`) : Les tailles des couches de l'encodeur de points clés.

gnn_layers_types (`list[str]`, *facultatif*, par défaut `['self', 'cross', 'self', 'cross', 'self', 'cross', 'self', 'cross', 'self', 'cross', 'self', 'cross', 'self', 'cross', 'self', 'cross', 'self', 'cross']`) : Les types des couches GNN. Doit être soit 'self', soit 'cross'.

num_attention_heads (`int`, *facultatif*, valeur par défaut `4`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

sinkhorn_iterations (`int`, *facultatif*, valeur par défaut : 100) : Le nombre d'itérations de Sinkhorn.

matching_threshold (`float`, *facultatif*, par défaut 0.0) : Le seuil de correspondance.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

is_decoder (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle est utilisé comme décodeur. Si `False`, le modèle est utilisé comme encodeur.

attention_probs_dropout_prob (`Union[int, float]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

Il s'agit de la classe de configuration permettant de stocker la configuration d'un SuperglueModel. Elle est utilisée pour instancier un modèle Superglue en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [magic-leap-community/superglue_indoor](https://huggingface.co/magic-leap-community/superglue_indoor)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemples :
```python
>>> from transformers import SuperGlueConfig, SuperGlueModel

>>> # Initializing a SuperGlue superglue style configuration
>>> configuration = SuperGlueConfig()

>>> # Initializing a model from the superglue style configuration
>>> model = SuperGlueModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## SuperGlueImageProcessor[[transformers.SuperGlueImageProcessor]]

#### transformers.SuperGlueImageProcessor[[transformers.SuperGlueImageProcessor]]

```python
transformers.SuperGlueImageProcessor(**kwargs: *<class 'transformers.models.superglue.image_processing_superglue.SuperGlueImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_superglue.py#L124)

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 480, 'width': 640}`) : Décrit les dimensions d'entrée maximales pour le modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `None`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

do_grayscale (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_grayscale`) : Indique s'il faut convertir l'image en niveaux de gris. Peut être remplacé par `do_grayscale` dans la méthode `preprocess`.

Construit un processeur d’images SuperGlueImageProcessor.

#### prétraiter[[transformers.SuperGlueImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *<class 'transformers.models.superglue.image_processing_superglue.SuperGlueImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_superglue.py#L138)

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

do_grayscale (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_grayscale`) : Indique s'il faut convertir l'image en niveaux de gris. Peut être remplacé par `do_grayscale` dans la méthode `preprocess`.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

#### post_process_keypoint_matching[[transformers.SuperGlueImageProcessor.post_process_keypoint_matching]]

```python
post_process_keypoint_matching(outputs: SuperGlueKeypointMatchingOutput, target_sizes: transformers.utils.generic.TensorType | list[tuple], threshold: float = 0.0)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_superglue.py#L194)

**Paramètres :**

outputs (`SuperGlueKeypointMatchingOutput`) : Sorties brutes du modèle.

target_sizes (`torch.Tensor` ou `list[tuple[tuple[int, int]]]`, *facultatif*) : Tenseur de forme `(batch_size, 2, 2)` ou liste de tuples de tuples (`tuple[int, int]`) contenant la taille cible `(height, width)` de chaque image du lot. Il doit s'agir de la taille d'image d'origine (avant tout traitement).

threshold (`float`, *facultatif*, valeur par défaut `0.0`) : Seuil pour filtrer les correspondances ayant des scores faibles.

**Retourne :** `list[Dict]`

Une liste de dictionnaires, chaque dictionnaire contenant les points clés de la première et de la seconde image de la paire, les scores d'appariement et les indices d'appariement.

Convertit la sortie brute de `SuperGlueKeypointMatchingOutput` en listes de points clés, de scores et de descripteurs, avec des coordonnées absolues par rapport aux dimensions d'origine des images.

#### visualize_keypoint_matching[[transformers.SuperGlueImageProcessor.visualize_keypoint_matching]]

```python
visualize_keypoint_matching(images, keypoint_matching_output: list)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_superglue.py#L262)

**Paramètres :**

images : Paires d'images à tracer. Identique à `EfficientLoFTRImageProcessor.preprocess`. Attend soit une liste de 2 images, soit une liste de listes de 2 images, avec des valeurs de pixels comprises entre 0 et 255.

keypoint_matching_output (List[Dict[str, torch.Tensor]]]) : sortie de correspondance de points clés post-traitée

**Retourne :** `List[PIL.Image.Image]`

Une liste d'images PIL, chacune contenant les paires d'images côte à côte avec les points clés détectés ainsi que l'appariement entre eux.

Affiche les paires d’images côte à côte avec les points clés détectés ainsi que les correspondances entre eux.

## SuperGlueImageProcessorPil[[transformers.SuperGlueImageProcessorPil]]

#### transformers.SuperGlueImageProcessorPil[[transformers.SuperGlueImageProcessorPil]]

```python
transformers.SuperGlueImageProcessorPil(**kwargs: *<class 'transformers.models.superglue.image_processing_pil_superglue.SuperGlueImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_pil_superglue.py#L117)

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 480, 'width': 640}`) : Décrit les dimensions d'entrée maximales pour le modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `None`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

do_grayscale (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_grayscale`) : Indique s'il faut convertir l'image en niveaux de gris. Peut être remplacé par `do_grayscale` dans la méthode `preprocess`.

Construit un processeur d’images SuperGlueImageProcessor.

#### prétraiter[[transformers.SuperGlueImageProcessorPil.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *<class 'transformers.models.superglue.image_processing_pil_superglue.SuperGlueImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_pil_superglue.py#L131)

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

do_grayscale (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_grayscale`) : Indique s'il faut convertir l'image en niveaux de gris. Peut être remplacé par `do_grayscale` dans la méthode `preprocess`.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

#### post_process_keypoint_matching[[transformers.SuperGlueImageProcessorPil.post_process_keypoint_matching]]

```python
post_process_keypoint_matching(outputs: SuperGlueKeypointMatchingOutput, target_sizes: transformers.utils.generic.TensorType | list[tuple], threshold: float = 0.0)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_pil_superglue.py#L172)

**Paramètres :**

outputs (`SuperGlueKeypointMatchingOutput`) : Sorties brutes du modèle.

target_sizes (`torch.Tensor` ou `list[tuple[tuple[int, int]]]`, *facultatif*) : Tenseur de forme `(batch_size, 2, 2)` ou liste de tuples de tuples (`tuple[int, int]`) contenant la taille cible `(height, width)` de chaque image du lot. Il doit s'agir de la taille d'image d'origine (avant tout traitement).

threshold (`float`, *facultatif*, valeur par défaut `0.0`) : Seuil pour filtrer les correspondances ayant des scores faibles.

**Retourne :** `list[Dict]`

Une liste de dictionnaires, chaque dictionnaire contenant les points clés de la première et de la seconde image de la paire, les scores d'appariement et les indices d'appariement.

Convertit la sortie brute de `SuperGlueKeypointMatchingOutput` en listes de points clés, de scores et de descripteurs, avec des coordonnées absolues par rapport aux dimensions d'origine des images.

#### visualize_keypoint_matching[[transformers.SuperGlueImageProcessorPil.visualize_keypoint_matching]]

```python
visualize_keypoint_matching(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], keypoint_matching_output: list)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_pil_superglue.py#L243)

**Paramètres :**

images (`ImageInput`) : Paires d'images à tracer. Identique à `SuperGlueImageProcessor.preprocess`. Attend soit une liste de 2 images, soit une liste de listes de 2 images, avec des valeurs de pixels comprises entre 0 et 255.

keypoint_matching_output (List[Dict[str, torch.Tensor]]]) : sortie de correspondance de points clés post-traitée

**Retourne :** `List[PIL.Image.Image]`

Une liste d'images PIL, chacune contenant les paires d'images côte à côte avec les points clés détectés ainsi que l'appariement entre eux.

Affiche les paires d’images côte à côte avec les points clés détectés ainsi que les correspondances entre eux.

## SuperGlueForKeypointMatching[[transformers.SuperGlueForKeypointMatching]]

#### transformers.SuperGlueForKeypointMatching[[transformers.SuperGlueForKeypointMatching]]

```python
transformers.SuperGlueForKeypointMatching(config: SuperGlueConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/modeling_superglue.py#L486)

**Paramètres :**

config ([SuperGlueConfig](/docs/transformers/main/fr/model_doc/superglue#transformers.SuperGlueConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle SuperGlue qui prend des images en entrée et produit leur appariement en sortie.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.SuperGlueForKeypointMatching.forward]]

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/modeling_superglue.py#L665)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [SuperGlueImageProcessor](/docs/transformers/main/fr/model_doc/superglue#transformers.SuperGlueImageProcessor). Voir [SuperGlueImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [SuperGlueImageProcessor](/docs/transformers/main/fr/model_doc/superglue#transformers.SuperGlueImageProcessor) pour le traitement des images).

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** `SuperGlueKeypointMatchingOutput` ou `tuple(torch.Tensor)`

Un `SuperGlueKeypointMatchingOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([SuperGlueConfig](/docs/transformers/main/fr/model_doc/superglue#transformers.SuperGlueConfig)) et les entrées.

La méthode forward de [SuperGlueForKeypointMatching](/docs/transformers/main/fr/model_doc/superglue#transformers.SuperGlueForKeypointMatching) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*) -- Perte calculée pendant l'entraînement.
- **correspondances** (`torch.Tensor` de forme `(batch_size, 2, num_matches)`) -- Index des points clés appariés dans l'autre image.
- **matching_scores** (`torch.Tensor` de forme `(batch_size, 2, num_matches)`) -- Scores des correspondances prédites.
- **keypoints** (`torch.Tensor` de forme `(batch_size, num_keypoints, 2)`) -- Coordonnées (x, y) absolues des points clés prédits dans une image donnée.
- **mask** (`torch.IntTensor` de forme `(batch_size, num_keypoints)`) -- Masque indiquant quelles valeurs dans matches et matching_scores correspondent à des informations d'appariement de points clés.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*) -- Tuple de `torch.Tensor` (un pour la sortie de chaque étape) de forme `(batch_size, 2, num_channels, num_keypoints)`, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`)
- **attentions** (`tuple[torch.Tensor, ...]`, *facultatif*) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, 2, num_heads, num_keypoints, num_keypoints)`, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`)

Exemples :

```python
>>> from transformers import AutoImageProcessor, AutoModel
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "https://github.com/magicleap/SuperGluePretrainedNetwork/blob/master/assets/phototourism_sample_images/london_bridge_78916675_4568141288.jpg?raw=true"
>>> with httpx.stream("GET", url) as response:
...     image_1 = Image.open(BytesIO(response.read()))

>>> url = "https://github.com/magicleap/SuperGluePretrainedNetwork/blob/master/assets/phototourism_sample_images/london_bridge_19481797_2295892421.jpg?raw=true"
>>> with httpx.stream("GET", url) as response:
...     image_2 = Image.open(BytesIO(response.read()))

>>> images = [image_1, image_2]

>>> processor = AutoImageProcessor.from_pretrained("magic-leap-community/superglue_outdoor")
>>> model = AutoModel.from_pretrained("magic-leap-community/superglue_outdoor")

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