Hugging Face's logo

Transformers documentation

Modelos de codificador-decodificador de visión

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 21-09-2021 y se contribuyó a Hugging Face Transformers el 13-10-2021.

Modelos de codificador-decodificador de visión

FlashAttention SDPA

Resumen

El VisionEncoderDecoderModel se puede utilizar para inicializar un modelo de imagen a texto con cualquier modelo de visión preentrenado basado en Transformers como codificador (por ejemplo ViT, BEiT, DeiT, Swin) y cualquier modelo de lenguaje preentrenado como decodificador (por ejemplo RoBERTa, GPT2, BERT, DistilBERT).

Se ha demostrado la eficacia de inicializar modelos de imagen a secuencia de texto con puntos de control preentrenados en (por ejemplo) TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models de Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei.

Después de que un VisionEncoderDecoderModel se haya entrenado/ajustado, se puede guardar/cargar igual que cualquier otro modelo (consulte los ejemplos a continuación para obtener más información).

Un ejemplo de aplicación es la generación de descripciones de imágenes, en la que se utiliza el codificador para codificar la imagen, tras lo cual un modelo de lenguaje autoregresivo genera la descripción. Otro ejemplo es el reconocimiento óptico de caracteres. Consulte TrOCR, que es una instancia de VisionEncoderDecoderModel.

Inicialización aleatoria de VisionEncoderDecoderModel a partir de las configuraciones del modelo

VisionEncoderDecoderModel se puede inicializar aleatoriamente a partir de la configuración de un codificador y un decodificador. En el siguiente ejemplo, se muestra cómo hacerlo utilizando la configuración predeterminada de ViTModel para el codificador y la configuración predeterminada de BertForCausalLM para el decodificador.

from transformers import BertConfig, VisionEncoderDecoderConfig, VisionEncoderDecoderModel, ViTConfig


config_encoder = ViTConfig()
config_decoder = BertConfig()

config = VisionEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
model = VisionEncoderDecoderModel(config=config)

Inicializar VisionEncoderDecoderModel a partir de un codificador preentrenado y un decodificador preentrenado

VisionEncoderDecoderModel se puede inicializar a partir de un checkpoint preentrenado del codificador y un checkpoint preentrenado del decodificador. Tenga en cuenta que cualquier modelo de visión basado en Transformers preentrenado, por ejemplo Swin, puede servir como codificador, y tanto los modelos auto-entrenados preentrenados, por ejemplo BERT, como los modelos de lenguaje causales preentrenados, por ejemplo GPT2, así como la parte de decodificador preentrenada de los modelos de secuencia a secuencia, por ejemplo el decodificador de BART, pueden usarse como decodificador. Dependiendo de la arquitectura que elija como decodificador, las capas de atención cruzada podrían inicializarse aleatoriamente. Inicializar VisionEncoderDecoderModel a partir de un checkpoint preentrenado del codificador y del decodificador requiere que el modelo se ajuste fino en una tarea descendente, como se ha demostrado en la publicación en el blog sobre Warm-starting-encoder-decoder. Para ello, la clase VisionEncoderDecoderModel proporciona un método VisionEncoderDecoderModel.from_encoder_decoder_pretrained().

from transformers import VisionEncoderDecoderModel


model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
    "microsoft/swin-base-patch4-window7-224-in22k", "google-bert/bert-base-uncased"
)

Cargar un punto de control existente de VisionEncoderDecoderModel y realizar inferencia

Para cargar puntos de control afinados de la clase VisionEncoderDecoderModel, VisionEncoderDecoderModel proporciona el método from_pretrained(...) al igual que cualquier otra arquitectura de modelo en Transformers.

Para realizar la inferencia, se utiliza el método generate, que permite generar texto de forma autoregresiva. Este método admite diversas formas de decodificación, como la búsqueda voraz, la búsqueda por haces y la muestreo multinomial.

import requests
from PIL import Image

from transformers import GPT2TokenizerFast, ViTImageProcessor, VisionEncoderDecoderModel

# load a fine-tuned image captioning model and corresponding tokenizer and image processor
model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning", device_map="auto")
tokenizer = GPT2TokenizerFast.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
image_processor = ViTImageProcessor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")

# let's perform inference on an image
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
pixel_values = image_processor(image, return_tensors="pt").to(model.device).pixel_values

# autoregressively generate caption (uses greedy decoding by default)
generated_ids = model.generate(pixel_values)
generated_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(generated_text)
a cat laying on a blanket next to a cat laying on a bed

Entrenamiento

Una vez que se crea el modelo, se puede ajustar de forma similar a BART, T5 o cualquier otro modelo encoder-decoder en un conjunto de datos de pares (imagen, texto). Como puede ver, el modelo solo requiere 2 entradas para calcular una pérdida: pixel_values (que son las imágenes) y labels (que son los input_ids de la secuencia objetivo codificada).

from datasets import load_dataset

from transformers import BertTokenizer, VisionEncoderDecoderModel, ViTImageProcessor


image_processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
    "google/vit-base-patch16-224-in21k", "google-bert/bert-base-uncased"
)

model.config.decoder_start_token_id = tokenizer.cls_token_id
model.config.pad_token_id = tokenizer.pad_token_id

dataset = load_dataset("huggingface/cats-image")
image = dataset["test"]["image"][0]
pixel_values = image_processor(image, return_tensors="pt").to(model.device).pixel_values

labels = tokenizer(
    "an image of two cats chilling on a couch",
    return_tensors="pt",
).input_ids

# the forward function automatically creates the correct decoder_input_ids
loss = model(pixel_values=pixel_values, labels=labels).loss

Este modelo fue aportado por nielsr.

VisionEncoderDecoderConfig

clase transformers.VisionEncoderDecoderConfig

< >

( 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Trueencoder: transformers.configuration_utils.PreTrainedConfig | dict | None = Nonedecoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None )

Parámetros

  • is_encoder_decoder (bool, opcional, valor predeterminado True) — Indica si el modelo se utiliza como codificador/decodificador o no.
  • encoder (Union[~configuration_utils.PreTrainedConfig, dict], opcional) — El objeto de configuración o el diccionario del backbone del codificador.
  • decoder (Union[~configuration_utils.PreTrainedConfig, dict], opcional) — El objeto de configuración o el diccionario del backbone del decodificador.

Esta es la clase de configuración para almacenar la configuración de un modelo Vision Encoder Decoder. Se utiliza para instanciar un modelo Vision Encoder Decoder 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 None

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 BertConfig, ViTConfig, VisionEncoderDecoderConfig, VisionEncoderDecoderModel

>>> # Initializing a ViT & BERT style configuration
>>> config_encoder = ViTConfig()
>>> config_decoder = BertConfig()

>>> config = VisionEncoderDecoderConfig(encoder=config_encoder, decoder=config_decoder)

>>> # Initializing a ViTBert model (with random weights) from a ViT & google-bert/bert-base-uncased style configurations
>>> model = VisionEncoderDecoderModel(config=config)

>>> # Accessing the model configuration
>>> config_encoder = model.config.encoder
>>> config_decoder = model.config.decoder
>>> # set decoder config to causal lm
>>> config_decoder.is_decoder = True
>>> config_decoder.add_cross_attention = True

>>> # Saving the model, including its configuration
>>> model.save_pretrained("my-model")

>>> # loading model and config from pretrained folder
>>> encoder_decoder_config = VisionEncoderDecoderConfig.from_pretrained("my-model")
>>> model = VisionEncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)

from_encoder_decoder_configs

< >

( encoder_config: PreTrainedConfigdecoder_config: PreTrainedConfig**kwargs ) → VisionEncoderDecoderConfig

Devuelve

VisionEncoderDecoderConfig

Una instancia de un objeto de configuración

Instanciar una VisionEncoderDecoderConfig (o una clase derivada) a partir de la configuración de un modelo codificador preentrenado y la configuración de un modelo decodificador.

VisionEncoderDecoderModel

clase transformers.VisionEncoderDecoderModel

< >

( config: transformers.configuration_utils.PreTrainedConfig | None = Noneencoder: transformers.modeling_utils.PreTrainedModel | None = Nonedecoder: transformers.modeling_utils.PreTrainedModel | None = None )

Parámetros

  • config (PreTrainedConfig, opcional) — 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.
  • encoder (PreTrainedModel, opcional) — El modelo codificador a utilizar.
  • decoder (PreTrainedModel, opcional) — El modelo decodificador a utilizar.

El modelo Vision Encoder Decoder básico que genera estados ocultos sin ningún cabezal específico 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.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → Seq2SeqLMOutput or tuple(torch.Tensor)

Parámetros

  • pixel_values (torch.Tensor 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 image_processor_class. Consulte image_processor_class.__call__ para más detalles (processor_class utiliza image_processor_class para procesar las imágenes).
  • decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando PreTrainedTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles. ¿Qué son los IDs de entrada? Si se usa past_key_values, opcionalmente solo se deben ingresar los últimos decoder_input_ids (consulte past_key_values). Para el entrenamiento, decoder_input_ids se crea automáticamente por el modelo desplazando las etiquetas hacia la derecha, reemplazando -100 por pad_token_id y añadiendo decoder_start_token_id al principio.

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

    ¿Qué son los IDs de entrada?

    Si se usa past_key_values, opcionalmente solo se deben introducir los últimos decoder_input_ids (ver past_key_values).

    Para el entrenamiento, decoder_input_ids se crean automáticamente por el modelo desplazando labels hacia la derecha, reemplazando -100 por pad_token_id y añadiendo decoder_start_token_id al principio.

  • decoder_attention_mask (torch.BoolTensor de forma (batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en decoder_input_ids. También se usará una máscara causal de forma predeterminada.
  • encoder_outputs (tuple[torch.Tensor], opcional) — La tupla consiste en (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.
  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • decoder_inputs_embeds (torch.Tensor de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar decoder_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 decoder_input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado del decodificador. Los índices deben estar en [-100, 0, ..., config.vocab_size] (ver la docstring de input_ids). Los tokens con índices fijados en -100 se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size]
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
  • output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
  • output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
  • return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

Seq2SeqLMOutput o tuple(torch.Tensor)

Un Seq2SeqLMOutput 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 (VisionEncoderDecoderConfig) y las entradas.

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

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje.

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).

  • past_key_values (EncoderDecoderCache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de EncoderDecoderCache. Para más detalles, consulte nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • decoder_hidden_states (tuple(torch.Tensor), opcional, se devuelve 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, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

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

  • decoder_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).

    Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • cross_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).

    Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

  • encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

  • encoder_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 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 codificador en la salida de cada capa más las salidas de la incrustación inicial.

  • encoder_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).

    Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

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

>>> processor = AutoProcessor.from_pretrained("microsoft/trocr-base-handwritten")
>>> model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")

>>> # load image from the IAM dataset
>>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read())).convert("RGB")

>>> # training
>>> model.config.decoder_start_token_id = processor.tokenizer.eos_token_id
>>> model.config.pad_token_id = processor.tokenizer.pad_token_id
>>> model.config.vocab_size = model.config.decoder.vocab_size

>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> text = "hello world"
>>> labels = processor.tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(pixel_values=pixel_values, labels=labels)
>>> loss = outputs.loss

>>> # inference (generation)
>>> generated_ids = model.generate(pixel_values)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

from_encoder_decoder_pretrained

< >

( encoder_pretrained_model_name_or_path: str | None = Nonedecoder_pretrained_model_name_or_path: str | None = None*model_args**kwargs )

Parámetros

  • encoder_pretrained_model_name_or_path (str, opcional) — Información necesaria para iniciar el codificador de imágenes. Puede ser:
    • Una cadena de texto, el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co. Un ejemplo es google/vit-base-patch16-224-in21k.
    • Una ruta a un directorio que contiene los pesos del modelo guardados con save_pretrained(), por ejemplo, ./my_model_directory/.
  • decoder_pretrained_model_name_or_path (str, opcional, por defecto None) — Información necesaria para iniciar el decodificador de texto. Puede ser:
    • Una cadena de texto, el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co.
    • Una ruta a un directorio que contiene los pesos del modelo guardados con save_pretrained(), por ejemplo, ./my_model_directory/.
  • model_args (argumentos posicionales restantes, opcional) — Todos los argumentes posicionales restantes se pasarán al método __init__ del modelo subyacente.
  • kwargs (diccionario restante de argumentos de palabra clave, opcional) — Se puede usar para actualizar el objeto de configuración (después de que se haya cargado) e iniciar el modelo (p. ej., output_attentions=True).
    • Para actualizar la configuración del codificador, use el prefijo encoder_ para cada parámetro de configuración.
    • Para actualizar la configuración del decodificador, use el prefijo decoder_ para cada parámetro de configuración.
    • Para actualizar la configuración del modelo principal, no utilice un prefijo para cada parámetro de configuración.

    Se comporta de manera diferente dependiendo de si se proporciona un config o se carga automáticamente.

Instanciar un codificador y un decodificador a partir de una o dos clases base de la biblioteca desde puntos de control de modelos preentrenados.

El modelo se establece en modo de evaluación de forma predeterminada mediante model.eval() (los módulos Dropout se desactivan). Para entrenar el modelo, primero debe volver a establecerlo en modo de entrenamiento con model.train().

Ejemplo:

>>> from transformers import VisionEncoderDecoderModel

>>> # initialize a vit-bert from a pretrained ViT and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "google-bert/bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-bert")
>>> # load fine-tuned model
>>> model = VisionEncoderDecoderModel.from_pretrained("./vit-bert")
Update on GitHub

←VipLlava Codificador dual de visión y texto→