Transformers documentation

ALIGN

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 2021-02-11 y se contribuyó a Hugging Face Transformers el 2023-03-01.

Transformers

ALIGN

ALIGN se preentrena en un conjunto de datos ruidoso de 1.800 millones de pares de texto alternativo e imágenes para demostrar que la escala puede compensar el ruido. Utiliza una arquitectura de doble codificador, EfficientNet para las imágenes y BERT para el texto, y una pérdida contrastiva para alinear los embeddings de imagen y texto similares entre sí, mientras aleja los embeddings diferentes. Una vez entrenado, ALIGN puede codificar cualquier imagen y las leyendas candidatas en un espacio vectorial compartido para la recuperación o clasificación zero-shot, sin necesidad de etiquetas adicionales. Este enfoque centrado en la escala reduce los costos de curaduría del conjunto de datos y permite la recuperación de imagen y texto y la clasificación zero-shot de ImageNet con el estado del arte.

Puedes encontrar todos los puntos de control originales de ALIGN bajo la organización Kakao Brain.

Haz clic en los modelos ALIGN en la barra lateral derecha para ver más ejemplos de cómo aplicar ALIGN a diferentes tareas relacionadas con la visión y el texto.

El siguiente ejemplo demuestra la clasificación de imágenes en cero disparos con Pipeline o la clase AutoModel.

Pipeline
AutoModel
from transformers import pipeline


pipeline = pipeline(
    task="zero-shot-image-classification",
    model="kakaobrain/align-base",
    device=0,
)

candidate_labels = [
    "a photo of a dog",
    "a photo of a cat",
    "a photo of a person"
]

pipeline("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg", candidate_labels=candidate_labels)

Notas

  • ALIGN proyecta las características de texto y visuales en el espacio latente y el producto punto entre las características de imagen y texto proyectadas se utiliza como puntuación de similitud. El siguiente ejemplo demuestra cómo calcular la puntuación de similitud imagen-texto con AlignProcessor y AlignModel.

    # Example of using ALIGN for image-text similarity
    from transformers import AlignProcessor, AlignModel
    import torch
    from PIL import Image
    import requests
    from io import BytesIO
    
    # Load processor and model
    processor = AlignProcessor.from_pretrained("kakaobrain/align-base")
    model = AlignModel.from_pretrained("kakaobrain/align-base", device_map="auto")
    
    # Download image from URL
    url = "https://huggingface.co/roschmid/dog-races/resolve/main/images/Golden_Retriever.jpg"
    response = requests.get(url)
    image = Image.open(BytesIO(response.content))  # Convert the downloaded bytes to a PIL Image
    
    texts = ["a photo of a cat", "a photo of a dog"]
    
    # Process image and text inputs
    inputs = processor(images=image, text=texts, return_tensors="pt").to(model.device)
    
    # Get the embeddings
    with torch.no_grad():
        outputs = model(**inputs)
    
    image_embeds = outputs.image_embeds
    text_embeds = outputs.text_embeds
    
    # Normalize embeddings for cosine similarity
    image_embeds = image_embeds / image_embeds.norm(dim=1, keepdim=True)
    text_embeds = text_embeds / text_embeds.norm(dim=1, keepdim=True)
    
    # Calculate similarity scores
    similarity_scores = torch.matmul(text_embeds, image_embeds.T)
    
    # Print raw scores
    print("Similarity scores:", similarity_scores)
    
    # Convert to probabilities
    probs = torch.nn.functional.softmax(similarity_scores, dim=0)
    print("Probabilities:", probs)
    
    # Get the most similar text
    most_similar_idx = similarity_scores.argmax().item()
    print(f"Most similar text: '{texts[most_similar_idx]}'")

Recursos

AlignConfig

clase transformers.AlignConfig

< >

( 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 = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneprojection_dim: int = 640temperature_init_value: float = 1.0initializer_range: float = 0.02 )

Parámetros

  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de texto.
  • vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — El objeto de configuración o el diccionario del backbone de visión.
  • projection_dim (int, opcional, valor predeterminado 640) — Dimensionalidad de las capas de proyección de texto y visión.
  • temperature_init_value (float, opcional, valor predeterminado 1.0) — El valor inicial del parámetro temperature. El valor predeterminado se utiliza según la implementación original de ALIGN.
  • 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 AlignModel. Se utiliza para instanciar un modelo Align 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 kakaobrain/align-base

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.

Ejemplo:

>>> from transformers import AlignConfig, AlignModel

>>> # Initializing a AlignConfig with kakaobrain/align-base style configuration
>>> configuration = AlignConfig()

>>> # Initializing a AlignModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignModel(configuration)

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

>>> # We can also initialize a AlignConfig from a AlignTextConfig and a AlignVisionConfig
>>> from transformers import AlignTextConfig, AlignVisionConfig

>>> # Initializing ALIGN Text and Vision configurations
>>> config_text = AlignTextConfig()
>>> config_vision = AlignVisionConfig()

>>> config = AlignConfig(text_config=config_text, vision_config=config_vision)

AlignTextConfig

clase transformers.AlignTextConfig

< >

( 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 = Nonevocab_size: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2initializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0bos_token_id: int | None = Noneeos_token_id: int | list[int] | None = None )

Parámetros

  • vocab_size (int, opcional, valor predeterminado 30522) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
  • hidden_size (int, opcional, valor predeterminado 768) — Dimensión de las representaciones ocultas.
  • num_hidden_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • intermediate_size (int, opcional, valor predeterminado 3072) — Dimensión de las representaciones del MLP.
  • hidden_act (str, opcional, valor predeterminado gelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • hidden_dropout_prob (Union[float, int], opcional, valor predeterminado 0.1) — La probabilidad de dropout para todas las capas totalmente conectadas en las incrustaciones, el codificador y el pooler.
  • attention_probs_dropout_prob (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las probabilidades de atención.
  • max_position_embeddings (int, opcional, valor predeterminado 512) — La longitud máxima de secuencia con la que se podría utilizar este modelo.
  • type_vocab_size (int, opcional, valor predeterminado 2) — El tamaño del vocabulario de token_type_ids.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-12) — El epsilon utilizado por las capas de normalización de capa.
  • pad_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el relleno en el vocabulario.
  • bos_token_id (int, opcional) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional) — Id del token utilizado para el fin de secuencia en el vocabulario.

Esta es la clase de configuración para almacenar la configuración de un AlignModel. Se utiliza para instanciar un modelo Align 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 kakaobrain/align-base

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.

Ejemplo:

>>> from transformers import AlignTextConfig, AlignTextModel

>>> # Initializing a AlignTextConfig with kakaobrain/align-base style configuration
>>> configuration = AlignTextConfig()

>>> # Initializing a AlignTextModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignTextModel(configuration)

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

AlignVisionConfig

clase transformers.AlignVisionConfig

< >

( 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 = Nonenum_channels: int = 3image_size: int | list[int] | tuple[int, int] = 600width_coefficient: float = 2.0depth_coefficient: float = 3.1depth_divisor: int = 8kernel_sizes: list[int] | tuple[int, ...] = (3, 3, 5, 3, 5, 5, 3)in_channels: list[int] | tuple[int, ...] = (32, 16, 24, 40, 80, 112, 192)out_channels: list[int] | tuple[int, ...] = (16, 24, 40, 80, 112, 192, 320)depthwise_padding: list | tuple[int, ...] = ()strides: list[int] | tuple[int, ...] = (1, 2, 2, 2, 1, 2, 1)num_block_repeats: list[int] | tuple[int, ...] = (1, 2, 2, 3, 3, 4, 1)expand_ratios: list[int] | tuple[int, ...] = (1, 6, 6, 6, 6, 6, 6)squeeze_expansion_ratio: float = 0.25hidden_act: str = 'swish'hidden_dim: int = 2560pooling_type: str = 'mean'initializer_range: float = 0.02batch_norm_eps: float = 0.001batch_norm_momentum: float = 0.99drop_connect_rate: float | int = 0.2 )

Parámetros

  • num_channels (int, opcional, valor predeterminado 3) — El número de canales de entrada.
  • image_size (Union[int, list[int], tuple[int, int]], opcional, valor predeterminado 600) — El tamaño (resolución) de cada imagen.
  • width_coefficient (float, opcional, valor predeterminado 2.0) — Coeficiente de escalado para el ancho de la red en cada etapa.
  • depth_coefficient (float, opcional, valor predeterminado 3.1) — Coeficiente de escalado para la profundidad de la red en cada etapa.
  • depth_divisor (int, opcional, valor predeterminado 8) — Una unidad de ancho de red.
  • kernel_sizes (list[int], opcional, valor predeterminado [3, 3, 5, 3, 5, 5, 3]) — Lista de tamaños de kernel que se utilizarán en cada bloque.
  • in_channels (list[int], opcional, valor predeterminado [32, 16, 24, 40, 80, 112, 192]) — Lista de tamaños de canales de entrada que se utilizarán en cada bloque para las capas convolucionales.
  • out_channels (list[int], opcional, valor predeterminado [16, 24, 40, 80, 112, 192, 320]) — Lista de tamaños de canales de salida que se utilizarán en cada bloque para las capas convolucionales.
  • depthwise_padding (list[int], opcional, valor predeterminado []) — Lista de índices de bloques con relleno cuadrado.
  • strides (list[int], opcional, valor predeterminado [1, 2, 2, 2, 1, 2, 1]) — Lista de tamaños de paso a utilizar en cada bloque para las capas convolucionales.
  • num_block_repeats (list[int], opcional, valor predeterminado [1, 2, 2, 3, 3, 4, 1]) — Lista con el número de veces que se debe repetir cada bloque.
  • expand_ratios (list[int], opcional, valor predeterminado [1, 6, 6, 6, 6, 6, 6]) — Lista de coeficientes de escalado de cada bloque.
  • squeeze_expansion_ratio (float, opcional, valor predeterminado 0.25) — Relación de expansión de compresión.
  • hidden_act (str, opcional, valor predeterminado swish) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • hidden_dim (int, opcional, valor predeterminado 1280) — La dimensión oculta de la capa antes de la cabeza de clasificación.
  • pooling_type (str o function, opcional, valor predeterminado "mean") — Tipo de agrupación final que se aplicará antes de la cabeza de clasificación densa. Las opciones disponibles son ["mean", "max"]
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • batch_norm_eps (float, opcional, valor predeterminado 0.001) — La epsilon utilizada por las capas de normalización por lote.
  • batch_norm_momentum (float, opcional, valor predeterminado 0.99) — El momento utilizado por las capas de normalización por lote.
  • drop_connect_rate (float, opcional, valor predeterminado 0.2) — La tasa de descarte para las conexiones de salto.

Esta es la clase de configuración para almacenar la configuración de un AlignModel. Se utiliza para instanciar un modelo Align 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 kakaobrain/align-base

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.

Ejemplo:

>>> from transformers import AlignVisionConfig, AlignVisionModel

>>> # Initializing a AlignVisionConfig with kakaobrain/align-base style configuration
>>> configuration = AlignVisionConfig()

>>> # Initializing a AlignVisionModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignVisionModel(configuration)

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

AlignProcessor

clase transformers.AlignProcessor

< >

( image_processortokenizer )

Parámetros

  • image_processor (EfficientNetImageProcessor) — El procesador de imágenes es una entrada obligatoria.
  • tokenizer (BertTokenizer) — El tokenizador es una entrada obligatoria.

Construye un AlignProcessor que envuelve un procesador de imágenes y un tokenizador en un único procesador.

AlignProcessor ofrece todas las funcionalidades de EfficientNetImageProcessor y BertTokenizer. Consulte ~EfficientNetImageProcessor y ~BertTokenizer para obtener más información.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> )

Parámetros

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — 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.
  • text (Union[str, list[str], list[list[str]]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pre-tokenizadas). Si se pasa una entrada pre-tokenizada, establezca is_split_into_words=True para evitar ambigüedad con las entradas por lotes.
  • videos (Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], opcional) — Vídeo a preprocesar. Espera un único vídeo o un lote de vídeos con valores de píxeles que van de 0 a 255. Si se pasan vídeos con valores de píxeles entre 0 y 1, establece do_rescale=False.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) — El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de la muestra del audio.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

AlignModel

clase transformers.AlignModel

< >

( config: AlignConfig )

Parámetros

  • config (AlignConfig) — 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.

El modelo Align sin procesar, que emite estados ocultos crudos sin ninguna cabeza específica en la parte superior.

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

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonereturn_loss: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → AlignOutput or tuple(torch.FloatTensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando EfficientNetImageProcessor. Consulte EfficientNetImageProcessor.call() para más detalles (AlignProcessor utiliza EfficientNetImageProcessor para procesar las imágenes).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • token_type_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en [0, 1]:
    • 0 corresponde a un token de sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • return_loss (bool, opcional) — Indica si se debe devolver la pérdida contrastiva.

Devuelve

AlignOutput o tuple(torch.FloatTensor)

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

El método forward de AlignModel 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.FloatTensor de forma (1,), opcional, devuelta cuando return_loss es True) — Pérdida contrastiva para la similitud imagen-texto.
  • logits_per_image (torch.FloatTensor de forma (image_batch_size, text_batch_size)) — Las puntuaciones de producto punto escalado entre image_embeds y text_embeds. Esto representa las puntuaciones de similitud entre imagen y texto.
  • logits_per_text (torch.FloatTensor de forma (text_batch_size, image_batch_size)) — Las puntuaciones de producto punto escalado entre text_embeds y image_embeds. Esto representa las puntuaciones de similitud texto-imagen.
  • text_embeds (torch.FloatTensor de forma (batch_size, output_dim) — Las incrustaciones de texto obtenidas al aplicar la capa de proyección a la salida agrupada de AlignTextModel.
  • image_embeds (torch.FloatTensor de forma (batch_size, output_dim) — La salida de AlignVisionModel.
  • text_model_output (~modeling_outputs.BaseModelOutputWithPooling, opcional) — La salida del AlignTextModel.
  • vision_model_output (~modeling_outputs.BaseModelOutputWithPoolingAndNoAttention, opcional) — La salida del AlignVisionModel.

Ejemplos:

>>> import torch
>>> from transformers import AutoProcessor, AlignModel
>>> from transformers.image_utils import load_image

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = load_image(url)

>>> inputs = processor(
...     images=image, text=["a photo of a cat", "a photo of a dog"], return_tensors="pt", padding=True
... )

>>> with torch.inference_mode():
...     outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities

get_text_features

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

Parámetros

  • input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • token_type_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en [0, 1]:
    • 0 corresponde a un token de sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

Devuelve

BaseModelOutputWithPooling o tuple(torch.FloatTensor)

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

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.FloatTensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

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

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

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

Ejemplos:

>>> import torch
>>> from transformers import AutoTokenizer, AlignModel

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> with torch.inference_mode():
...     text_features = model.get_text_features(**inputs)

get_image_features

< >

( pixel_values: FloatTensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

Parámetros

Devuelve

BaseModelOutputWithPooling o tuple(torch.FloatTensor)

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

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.FloatTensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

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

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

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

Ejemplos:

>>> import torch
>>> from transformers import AutoProcessor, AlignModel
>>> from transformers.image_utils import load_image

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = load_image(url)

>>> inputs = processor(images=image, return_tensors="pt")
>>> with torch.inference_mode():
...     image_features = model.get_image_features(**inputs)

AlignTextModel

clase transformers.AlignTextModel

< >

( config: AlignTextConfigadd_pooling_layer: bool = True )

Parámetros

  • config (AlignTextConfig) — 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.
  • add_pooling_layer (bool, opcional, valor predeterminado True) — Si se debe añadir una capa de pooling

El modelo de texto de ALIGN sin ninguna cabeza ni proyección en la parte superior.

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

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

Parámetros

  • input_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • token_type_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en [0, 1]:
    • 0 corresponde a un token de sentence A,
    • 1 corresponde a un token de sentence B.

    ¿Qué son los IDs de tipo de token?

  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

Devuelve

BaseModelOutputWithPooling o tuple(torch.FloatTensor)

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

El método forward de AlignTextModel 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.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.FloatTensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

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

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    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 AutoTokenizer, AlignTextModel

>>> model = AlignTextModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

AlignVisionModel

clase transformers.AlignVisionModel

< >

( config: AlignVisionConfig )

Parámetros

  • config (AlignVisionConfig) — 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.

El modelo de visión de ALIGN sin ninguna cabeza ni proyección en la parte superior.

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: typing.Optional[torch.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)

Parámetros

Devuelve

BaseModelOutputWithPoolingAndNoAttention o tuple(torch.FloatTensor)

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

El método forward de AlignVisionModel 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.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, num_channels, height, width)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.FloatTensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa después de una operación de agrupación en las dimensiones espaciales.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, num_channels, height, width).

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

Ejemplos:

>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, AlignVisionModel

>>> model = AlignVisionModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states
Update on GitHub