Hugging Face's logo

Transformers documentation

EfficientLoFTR

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 2024-03-07 y se contribuyó a Hugging Face Transformers el 2025-07-22.

PyTorch

EfficientLoFTR

EfficientLoFTR es un método eficiente de correspondencia de características locales sin detector que genera correspondencias semidensas entre imágenes con una velocidad similar a la de los métodos dispersos. Se basa en la arquitectura original de LoFTR, pero introduce mejoras significativas tanto en eficiencia como en precisión. La innovación clave es un mecanismo de atención agregada con selección adaptativa de tokens que hace que el modelo sea ~2,5 veces más rápido que LoFTR, al tiempo que logra una mayor precisión. EfficientLoFTR puede incluso superar a los pipelines de correspondencia dispersa eficientes de última generación, como SuperPoint + LightGlue, en términos de velocidad, lo que lo hace adecuado para aplicaciones a gran escala o sensibles a la latencia, como la recuperación de imágenes y la reconstrucción 3D.

Este modelo fue aportado por stevenbucaille.

Haz clic en los modelos EfficientLoFTR en la barra lateral derecha para ver más ejemplos de cómo aplicar EfficientLoFTR a diferentes tareas de visión por computadora.

El siguiente ejemplo demuestra cómo hacer coincidir puntos clave entre dos imágenes con Pipeline o la clase AutoModel.

Pipeline
AutoModel
from transformers import pipeline


keypoint_matcher = pipeline(task="keypoint-matching", model="zju-community/efficientloftr")

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': ...}

Notas

  • EfficientLoFTR está diseñado para la eficiencia manteniendo una alta precisión. Utiliza un mecanismo de atención agregado con selección adaptativa de tokens para reducir la sobrecarga computacional en comparación con el LoFTR original.

    from transformers import AutoImageProcessor, AutoModelForKeypointMatching
import torch
from PIL import Image
import requests

processor = AutoImageProcessor.from_pretrained("zju-community/efficientloftr")
model = AutoModelForKeypointMatching.from_pretrained("zju-community/efficientloftr", device_map="auto")

# EfficientLoFTR 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
keypoints = outputs.keypoints        # Keypoints in both images
matches = outputs.matches            # Matching indices 
matching_scores = outputs.matching_scores  # Confidence scores

  • El modelo produce coincidencias semidensas, lo que ofrece un buen equilibrio entre la densidad de las coincidencias y la eficiencia computacional. Destaca en el manejo de grandes cambios de punto de vista y en escenarios con poca textura.

  • Para una mejor visualización y análisis, use el método post_process_keypoint_matching() para obtener las coincidencias en un formato más legible.

    # 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}")

  • Visualice las coincidencias entre las imágenes utilizando la funcionalidad de trazado integrada.

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

  • EfficientLoFTR utiliza una capa de correlación de dos etapas novedosa que logra correspondencias subpixel precisas, mejorando el módulo de correlación fina del LoFTR original.

Recursos

EfficientLoFTRConfig

clase transformers.EfficientLoFTRConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonestage_num_blocks: list[int] | None = Noneout_features: list[int] | None = Nonestage_stride: list[int] | None = Nonehidden_size: int = 256activation_function: str = 'relu'q_aggregation_kernel_size: int = 4kv_aggregation_kernel_size: int = 4q_aggregation_stride: int = 4kv_aggregation_stride: int = 4num_attention_layers: int = 4num_attention_heads: int = 8attention_dropout: float | int = 0.0attention_bias: bool = Falsemlp_activation_function: str = 'leaky_relu'coarse_matching_skip_softmax: bool = Falsecoarse_matching_threshold: float = 0.2coarse_matching_temperature: float = 0.1coarse_matching_border_removal: int = 2fine_kernel_size: int = 8batch_norm_eps: float = 1e-05rope_parameters: dict | None = Nonefine_matching_slice_dim: int = 8fine_matching_regress_temperature: float = 10.0initializer_range: float = 0.02 )

Parámetros

  • stage_num_blocks (List, opcional, valor predeterminado [1, 2, 4, 14]) — El número de bloques en cada etapa
  • out_features (list[int], opcional) — Nombres de los estados ocultos intermedios (mapas de características) que se devolverán desde el backbone. Uno de "stem", "stage1", "stage2", etc.
  • stage_stride (List, opcional, por defecto [2, 1, 2, 2]) — El stride utilizado en cada etapa
  • hidden_size (int, opcional, valor predeterminado 256) — Dimensión de las representaciones ocultas.
  • activation_function (str, opcional, valor predeterminado relu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • q_aggregation_kernel_size (int, opcional, valor predeterminado 4) — El tamaño del kernel de la agregación de los estados de consulta en la red de fusión
  • kv_aggregation_kernel_size (int, opcional, valor predeterminado 4) — El tamaño del kernel de la agregación de los estados de clave y valor en la red de fusión
  • q_aggregation_stride (int, opcional, valor predeterminado 4) — La zancada de la agregación de los estados de consulta en la red de fusión
  • kv_aggregation_stride (int, opcional, valor predeterminado 4) — La distancia de agregación de los estados de clave y valor en la red de fusión
  • num_attention_layers (int, opcional, valor predeterminado 4) — Número de capas de atención en el LocalFeatureTransformer
  • num_attention_heads (int, opcional, valor predeterminado 8) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
  • attention_bias (bool, opcional, valor predeterminado False) — Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.
  • mlp_activation_function (str, opcional, por defecto "leaky_relu") — Función de activación utilizada en la capa mlp de la atención.
  • coarse_matching_skip_softmax (bool, opcional, valor predeterminado False) — Si se omite o no la softmax en el paso de correspondencia gruesa.
  • coarse_matching_threshold (float, opcional, valor predeterminado 0.2) — El umbral para la puntuación mínima requerida para una coincidencia.
  • coarse_matching_temperature (float, opcional, valor predeterminado 0.1) — La temperatura que se aplica a la matriz de similitud gruesa
  • coarse_matching_border_removal (int, opcional, valor predeterminado 2) — El tamaño del borde que se elimina durante la coincidencia gruesa
  • fine_kernel_size (int, opcional, valor predeterminado 8) — Tamaño del kernel utilizado para la coincidencia fina de características
  • batch_norm_eps (float, opcional, valor predeterminado 1e-05) — La epsilon utilizada por las capas de normalización por lote
  • rope_parameters (dict, opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para rope_theta y, opcionalmente, los parámetros utilizados para el escalado en caso de que desee usar RoPE con max_position_embeddings más largos.
  • fine_matching_slice_dim (int, opcional, valor predeterminado 8) — El tamaño de la porción utilizada para dividir las características finas en las primeras y segundas etapas de coincidencia fina.
  • fine_matching_regress_temperature (float, opcional, valor predeterminado 10.0) — La temperatura que se aplica a la matriz de similitud fina
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.

Esta es la clase de configuración para almacenar la configuración de un EfficientLoFTRModel. Se utiliza para instanciar un modelo Efficientloftr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de zju-community/efficientloftr

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplos:

>>> from transformers import EfficientLoFTRConfig, EfficientLoFTRForKeypointMatching

>>> # Initializing a EfficientLoFTR configuration
>>> configuration = EfficientLoFTRConfig()

>>> # Initializing a model from the EfficientLoFTR configuration
>>> model = EfficientLoFTRForKeypointMatching(configuration)

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

EfficientLoFTRImageProcessor

clase transformers.EfficientLoFTRImageProcessor

< >

( **kwargs: *<class 'transformers.models.efficientloftr.image_processing_efficientloftr.EfficientLoFTRImageProcessorKwargs'> )

Parámetros

  • do_convert_rgb (bool, kwargs, opcional) — Si se debe convertir la imagen a RGB.
  • do_resize (bool, kwargs, opcional, valor predeterminado True) — Si se debe redimensionar la imagen.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto {'height' -- 480, 'width': 640}): Describe las dimensiones de entrada máximas para el modelo.
  • default_to_square (bool, kwargs, opcional, valor predeterminado False) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamaño de la imagen de salida tras aplicar center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, por defecto 2) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los valores de la enumeración PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
  • do_rescale (bool, kwargs, opcional, valor predeterminado True) — Si se debe reescalar la imagen.
  • rescale_factor (float, kwargs, opcional, valor predeterminado 0.00392156862745098) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
  • do_normalize (bool, kwargs, opcional, valor predeterminado None) — Si se debe normalizar la imagen.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Media de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • do_pad (bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — El tamaño en {"height": int, "width" int} al que se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporciona pad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Si se debe recortar la imagen centrada.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admite ChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en 'pt'; en caso contrario, devuelve una lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • do_grayscale (bool, kwargs, opcional, valor predeterminado self.do_grayscale) — Si se debe convertir la imagen a escala de grises. Se puede sobrescribir mediante do_grayscale en el método preprocess.

Construye un procesador de imágenes EfficientLoFTRImageProcessor.

preprocesar

< >

( 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.efficientloftr.image_processing_efficientloftr.EfficientLoFTRImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Parámetros

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca do_rescale=False.
  • do_convert_rgb (bool, kwargs, opcional) — Si se debe convertir la imagen a RGB.
  • do_resize (bool, kwargs, opcional) — Si se debe redimensionar la imagen.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Describe las dimensiones de entrada máximas del modelo.
  • default_to_square (bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamaño de la imagen de salida tras aplicar center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los enum PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
  • do_rescale (bool, kwargs, opcional) — Si se debe reescalar la imagen.
  • rescale_factor (float, kwargs, opcional) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
  • do_normalize (bool, kwargs, opcional) — Si se debe normalizar la imagen.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Media de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • do_pad (bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — El tamaño en {"height": int, "width" int} al que se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporciona pad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Si se debe recortar la imagen centrada.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admite ChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en 'pt'; en caso contrario, devuelve una lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • do_grayscale (bool, kwargs, opcional, valor predeterminado self.do_grayscale) — Si se debe convertir la imagen a escala de grises. Se puede sobrescribir mediante do_grayscale en el método preprocess.

Devuelve

~image_processing_base.BatchFeature

  • data (dict) — Diccionario de listas/arrays/tensores devueltos por el método call (‘pixel_values’, etc.).
  • tensor_type (Union[None, str, TensorType], opcional) — Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

post_process_keypoint_matching

< >

( outputs: EfficientLoFTRKeypointMatchingOutputtarget_sizes: transformers.utils.generic.TensorType | list[tuple]threshold: float = 0.0 ) → List[Dict]

Parámetros

  • outputs (EfficientLoFTRKeypointMatchingOutput) — Salidas sin procesar del modelo.
  • target_sizes (torch.Tensor o List[Tuple[Tuple[int, int]]], opcional) — Tensor de forma (batch_size, 2, 2) o lista de tuplas de tuplas (Tuple[int, int]) que contiene el tamaño objetivo (height, width) de cada imagen del lote. Debe ser el tamaño original de la imagen (antes de cualquier procesamiento).
  • threshold (float, opcional, valor predeterminado 0.0) — Umbral para filtrar las coincidencias con puntuaciones bajas.

Devuelve

List[Dict]

Una lista de diccionarios, donde cada diccionario contiene los puntos clave de la primera y la segunda imagen de la pareja, las puntuaciones de correspondencia y los índices de correspondencia.

Convierte la salida cruda de EfficientLoFTRKeypointMatchingOutput en listas de puntos clave, puntuaciones y descriptores con coordenadas absolutas respecto a los tamaños originales de la imagen.

visualize_keypoint_matching

< >

( imageskeypoint_matching_output: list ) → List[PIL.Image.Image]

Parámetros

  • images — Pares de imágenes para graficar. Igual que EfficientLoFTRImageProcessor.preprocess. Espera una lista de 2 imágenes o una lista de listas de 2 imágenes con valores de píxeles que van de 0 a 255.
  • keypoint_matching_output (List[Dict[str, torch.Tensor]]) — Una salida de correspondencia de puntos clave procesada

Devuelve

List[PIL.Image.Image]

Una lista de imágenes PIL, cada una contiene los pares de imágenes lado a lado con los puntos clave detectados y la correspondencia entre ellos.

Muestra las parejas de imágenes lado a lado con los puntos clave detectados y la correspondencia entre ellos.

EfficientLoFTRImageProcessorPil

clase transformers.EfficientLoFTRImageProcessorPil

< >

( **kwargs: *<class 'transformers.models.efficientloftr.image_processing_pil_efficientloftr.EfficientLoFTRImageProcessorKwargs'> )

Parámetros

  • do_convert_rgb (bool, kwargs, opcional) — Si se debe convertir la imagen a RGB.
  • do_resize (bool, kwargs, opcional, valor predeterminado True) — Si se debe redimensionar la imagen.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto {'height' -- 480, 'width': 640}): Describe las dimensiones de entrada máximas para el modelo.
  • default_to_square (bool, kwargs, opcional, valor predeterminado False) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamaño de la imagen de salida tras aplicar center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, por defecto 2) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los valores de la enumeración PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
  • do_rescale (bool, kwargs, opcional, valor predeterminado True) — Si se debe reescalar la imagen.
  • rescale_factor (float, kwargs, opcional, valor predeterminado 0.00392156862745098) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
  • do_normalize (bool, kwargs, opcional, valor predeterminado None) — Si se debe normalizar la imagen.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Media de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • do_pad (bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — El tamaño en {"height": int, "width" int} al que se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporciona pad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Si se debe recortar la imagen centrada.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admite ChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en 'pt'; en caso contrario, devuelve una lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • do_grayscale (bool, kwargs, opcional, valor predeterminado self.do_grayscale) — Si se debe convertir la imagen a escala de grises. Se puede sobrescribir mediante do_grayscale en el método preprocess.

Construye un procesador de imágenes EfficientLoFTRImageProcessor.

preprocesar

< >

( 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.efficientloftr.image_processing_pil_efficientloftr.EfficientLoFTRImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Parámetros

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca do_rescale=False.
  • do_convert_rgb (bool, kwargs, opcional) — Si se debe convertir la imagen a RGB.
  • do_resize (bool, kwargs, opcional) — Si se debe redimensionar la imagen.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Describe las dimensiones de entrada máximas del modelo.
  • default_to_square (bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamaño de la imagen de salida tras aplicar center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los enum PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
  • do_rescale (bool, kwargs, opcional) — Si se debe reescalar la imagen.
  • rescale_factor (float, kwargs, opcional) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
  • do_normalize (bool, kwargs, opcional) — Si se debe normalizar la imagen.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Media de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • do_pad (bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — El tamaño en {"height": int, "width" int} al que se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporciona pad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Si se debe recortar la imagen centrada.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admite ChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en 'pt'; en caso contrario, devuelve una lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • do_grayscale (bool, kwargs, opcional, valor predeterminado self.do_grayscale) — Si se debe convertir la imagen a escala de grises. Se puede sobrescribir mediante do_grayscale en el método preprocess.

Devuelve

~image_processing_base.BatchFeature

  • data (dict) — Diccionario de listas/arrays/tensores devueltos por el método call (‘pixel_values’, etc.).
  • tensor_type (Union[None, str, TensorType], opcional) — Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

post_process_keypoint_matching

< >

( outputs: EfficientLoFTRKeypointMatchingOutputtarget_sizes: transformers.utils.generic.TensorType | list[tuple]threshold: float = 0.0 ) → List[Dict]

Parámetros

  • outputs (EfficientLoFTRKeypointMatchingOutput) — Salidas sin procesar del modelo.
  • target_sizes (torch.Tensor o List[Tuple[Tuple[int, int]]], opcional) — Tensor de forma (batch_size, 2, 2) o lista de tuplas de tuplas (Tuple[int, int]) que contiene el tamaño objetivo (height, width) de cada imagen del lote. Debe ser el tamaño original de la imagen (antes de cualquier procesamiento).
  • threshold (float, opcional, valor predeterminado 0.0) — Umbral para filtrar las coincidencias con puntuaciones bajas.

Devuelve

List[Dict]

Una lista de diccionarios, donde cada diccionario contiene los puntos clave de la primera y la segunda imagen de la pareja, las puntuaciones de correspondencia y los índices de correspondencia.

Convierte la salida cruda de EfficientLoFTRKeypointMatchingOutput en listas de puntos clave, puntuaciones y descriptores con coordenadas absolutas respecto a los tamaños originales de la imagen.

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 ) → List[PIL.Image.Image]

Parámetros

  • images (ImageInput) — Pares de imágenes para graficar. Igual que EfficientLoFTRImageProcessor.preprocess. Espera una lista de 2 imágenes o una lista de listas de 2 imágenes con valores de píxeles que van de 0 a 255.
  • keypoint_matching_output (List[Dict[str, torch.Tensor]]) — Una salida de correspondencia de puntos clave procesada

Devuelve

List[PIL.Image.Image]

Una lista de imágenes PIL, cada una contiene los pares de imágenes lado a lado con los puntos clave detectados y la correspondencia entre ellos.

Muestra las parejas de imágenes lado a lado con los puntos clave detectados y la correspondencia entre ellos.

EfficientLoFTRModel

clase transformers.EfficientLoFTRModel

< >

( config: EfficientLoFTRConfig )

Parámetros

  • config (EfficientLoFTRConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

Modelo EfficientLoFTR que toma imágenes como entradas y devuelve las características de las imágenes.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BackboneOutput or tuple(torch.Tensor)

Parámetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando EfficientLoFTRImageProcessor. Consulte EfficientLoFTRImageProcessor.call() para más detalles (processor_class utiliza EfficientLoFTRImageProcessor para procesar las imágenes).
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en [0, ..., config.vocab_size] o ser -100 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].

Devuelve

BackboneOutput o tuple(torch.Tensor)

Un BackboneOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (EfficientLoFTRConfig) y las entradas.

El método forward de EfficientLoFTRModel reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • feature_maps (tuple(torch.Tensor) de forma (batch_size, num_channels, height, width)) — Mapas de características de las etapas.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de los embeddings + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size) o (batch_size, num_channels, height, width), según el backbone.

    Estados ocultos del modelo en la salida de cada etapa más las salidas de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length). Solo aplicable si el backbone usa atención.

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

>>> 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:
...     image1 = 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:
...     image2 = Image.open(BytesIO(response.read()))

>>> images = [image1, image2]

>>> processor = AutoImageProcessor.from_pretrained("zju-community/efficient_loftr")
>>> model = AutoModel.from_pretrained("zju-community/efficient_loftr")

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

EfficientLoFTRForKeypointMatching

clase transformers.EfficientLoFTRForKeypointMatching

< >

( config: EfficientLoFTRConfig )

Parámetros

  • config (EfficientLoFTRConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

Modelo EfficientLoFTR que toma imágenes como entradas y produce su correspondencia.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → EfficientLoFTRKeypointMatchingOutput or tuple(torch.Tensor)

Parámetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando image_processor_class. Consulte image_processor_class.__call__ para más detalles (processor_class utiliza image_processor_class para procesar las imágenes).
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en [0, ..., config.vocab_size] o ser -100 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].

Devuelve

EfficientLoFTRKeypointMatchingOutput o tuple(torch.Tensor)

Un EfficientLoFTRKeypointMatchingOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (None) y las entradas.

El método forward de EfficientLoFTRForKeypointMatching sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional) — Pérdida calculada durante el entrenamiento.
  • coincidencias (torch.Tensor de forma (batch_size, 2, num_matches)) — Índice del punto clave coincidente en la otra imagen.
  • matching_scores (torch.Tensor de forma (batch_size, 2, num_matches)) — Puntuaciones de las coincidencias predichas.
  • keypoints (torch.Tensor de forma (batch_size, num_keypoints, 2)) — Coordenadas (x, y) absolutas de los keypoints predichos en una imagen dada.
  • hidden_states (tuple[torch.Tensor, ...], opcional) — Tupla de torch.Tensor (uno para la salida de cada etapa) de forma (batch_size, 2, num_channels, num_keypoints), devuelta cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True)
  • attentions (tuple[torch.Tensor, ...], opcional) — Tupla de torch.Tensor (uno por cada capa) de forma (batch_size, 2, num_heads, num_keypoints, num_keypoints), devuelta cuando se pasa output_attentions=True o cuando config.output_attentions=True)

Ejemplos:

>>> 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:
...     image1 = 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:
...     image2 = Image.open(BytesIO(response.read()))

>>> images = [image1, image2]

>>> processor = AutoImageProcessor.from_pretrained("zju-community/efficient_loftr")
>>> model = AutoModel.from_pretrained("zju-community/efficient_loftr")

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

←DPT EfficientNet→