# Modelos de codificador-decodificador de visión

## Resumen

El [VisionEncoderDecoderModel](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) se puede utilizar para inicializar un modelo de imagen a texto con cualquier modelo de visión preentrenado basado en Transformer como codificador (*por ejemplo* [ViT](vit), [BEiT](beit), [DeiT](deit), [Swin](swin)) y cualquier modelo de lenguaje preentrenado como decodificador (*por ejemplo* [RoBERTa](roberta), [GPT2](gpt2), [BERT](bert), [DistilBERT](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](https://huggingface.co/papers/2109.10282), de Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li y Furu Wei.

Después de que un [VisionEncoderDecoderModel](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.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](trocr), que es una instancia de [VisionEncoderDecoderModel](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel).

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

[VisionEncoderDecoderModel](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) se puede inicializar aleatoriamente a partir de la configuración de un codificador y un decodificador. En el siguiente ejemplo, mostramos cómo hacerlo utilizando la configuración predeterminada de [ViTModel](/docs/transformers/main/es/model_doc/vit#transformers.ViTModel) para el codificador y la configuración predeterminada de `BertForCausalLM` para el decodificador.

```python
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)
```

## Inicialización de `VisionEncoderDecoderModel` a partir de un codificador preentrenado y un decodificador preentrenado

[VisionEncoderDecoderModel](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.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](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](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.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*](https://huggingface.co/blog/warm-starting-encoder-decoder). Para ello, la clase `VisionEncoderDecoderModel` proporciona un método [VisionEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel.from_encoder_decoder_pretrained).

```python
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](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.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.

```python
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).

```python
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](https://github.com/nielsrogge).

## VisionEncoderDecoderConfig[[transformers.VisionEncoderDecoderConfig]]

#### transformers.VisionEncoderDecoderConfig[[transformers.VisionEncoderDecoderConfig]]

```python
transformers.VisionEncoderDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, encoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None, decoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/configuration_vision_encoder_decoder.py#L29)

**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](https://huggingface.co/None)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplos:

```python
>>> 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[[transformers.VisionEncoderDecoderConfig.from_encoder_decoder_configs]]

```python
from_encoder_decoder_configs(encoder_config: PreTrainedConfig, decoder_config: PreTrainedConfig, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/configuration_vision_encoder_decoder.py#L72)

**Devuelve:** [VisionEncoderDecoderConfig](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)

Una instancia de un objeto de configuración

Instanciar un [VisionEncoderDecoderConfig](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.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[[transformers.VisionEncoderDecoderModel]]

#### transformers.VisionEncoderDecoderModel[[transformers.VisionEncoderDecoderModel]]

```python
transformers.VisionEncoderDecoderModel(config: transformers.configuration_utils.PreTrainedConfig | None = None, encoder: transformers.modeling_utils.PreTrainedModel | None = None, decoder: transformers.modeling_utils.PreTrainedModel | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L54)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.VisionEncoderDecoderModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L301)

**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 usando `image_processor_class`. Consulte `image_processor_class.__call__` para obtener 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 mediante [PreTrainedTokenizer](/docs/transformers/main/es/main_classes/tokenizer#transformers.PythonBackend). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los input IDs?](../glossary#input-ids) Si se utiliza `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_ids` (consulte `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 cross-attention 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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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 establecidos en `-100` se ignoran (se enmascaran); 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 valores clave `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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [Seq2SeqLMOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) o `tuple(torch.Tensor)`

Un [Seq2SeqLMOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)) y las entradas.

El método forward de [VisionEncoderDecoderModel](/docs/transformers/main/es/model_doc/vision-encoder-decoder#transformers.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 preprocesamiento y posprocesamiento, 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](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (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:

```python
>>> 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[[transformers.VisionEncoderDecoderModel.from_encoder_decoder_pretrained]]

```python
from_encoder_decoder_pretrained(encoder_pretrained_model_name_or_path: str | None = None, decoder_pretrained_model_name_or_path: str | None = None, *model_args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L155)

**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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.save_pretrained), por ejemplo, `./my_model_directory/`.

decoder_pretrained_model_name_or_path (`str`, *opcional*, valor predeterminado `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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.save_pretrained), por ejemplo, `./my_model_directory/`.

model_args (argumentos posicionales restantes, *opcional*) : Todos los argumentos posicionales restantes se pasarán al método `__init__` del modelo subyacente.

kwargs (resto del diccionario de argumentos de palabras clave, *opcional*) : Se puede utilizar para actualizar el objeto de configuración (después de ser 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 use 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.

Instancia 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:

```python
>>> 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")
```