# Modelos Vision Encoder Decoder

## Visão geral

O [VisionEncoderDecoderModel](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) pode ser usado para inicializar um modelo de imagem para texto com qualquer modelo de visão pré-treinado baseado em Transformer como codificador (*por exemplo* [ViT](vit), [BEiT](beit), [DeiT](deit), [Swin](swin)) e qualquer modelo de linguagem pré-treinado como decodificador (*por exemplo* [RoBERTa](roberta), [GPT2](gpt2), [BERT](bert), [DistilBERT](distilbert)).

A eficácia da inicialização de modelos de imagem para sequência de texto com checkpoints pré-treinados foi demonstrada em (por exemplo) [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, Furu Wei.

Depois que um [VisionEncoderDecoderModel](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) é treinado/ajustado, ele pode ser salvo/carregado da mesma forma que qualquer outro modelo (veja os exemplos abaixo para mais informações).

Um exemplo de aplicação é a legendação de imagens, na qual o codificador é usado para codificar a imagem, após o que um modelo de linguagem autoregressivo gera a legenda. Outro exemplo é o reconhecimento óptico de caracteres. Consulte [TrOCR](trocr), que é uma instância de [VisionEncoderDecoderModel](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel).

## Inicializando aleatoriamente `VisionEncoderDecoderModel` a partir de configurações de modelo

[VisionEncoderDecoderModel](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) pode ser inicializado aleatoriamente a partir de uma configuração de encoder e uma configuração de decoder. No exemplo a seguir, mostramos como fazer isso usando a configuração padrão [ViTModel](/docs/transformers/main/pt/model_doc/vit#transformers.ViTModel) para o encoder e a configuração padrão `BertForCausalLM` para o decoder.

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

## Inicializando `VisionEncoderDecoderModel` a partir de um codificador pré-treinado e um decodificador pré-treinado

[VisionEncoderDecoderModel](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) pode ser inicializado a partir de um checkpoint pré-treinado de codificador e de um checkpoint pré-treinado de decodificador. Observe que qualquer modelo de visão baseado em Transformer pré-treinado, *por exemplo* [Swin](swin), pode servir como codificador e tanto os modelos auto-encodentes pré-treinados, *por exemplo* BERT, quanto os modelos de linguagem causal pré-treinados, *por exemplo* GPT2, bem como a parte de decodificador pré-treinada de modelos de sequência para sequência, *por exemplo* decodificador do BART, podem ser usados como decodificador. Dependendo da arquitetura escolhida como decodificador, as camadas de atenção cruzada podem ser inicializadas aleatoriamente. A inicialização do [VisionEncoderDecoderModel](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) a partir de um checkpoint de codificador e decodificador pré-treinados requer que o modelo seja ajustado em uma tarefa de nível inferior, conforme demonstrado em [o *post no blog Warm-starting-encoder-decoder*](https://huggingface.co/blog/warm-starting-encoder-decoder). Para isso, a classe `VisionEncoderDecoderModel` fornece um método [VisionEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/main/pt/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"
)
```

## Carregando um checkpoint existente de `VisionEncoderDecoderModel` e executando inferência

Para carregar checkpoints ajustados da classe `VisionEncoderDecoderModel`, o [VisionEncoderDecoderModel](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) fornece o método `from_pretrained(...)`, assim como qualquer outra arquitetura de modelo no Transformers.

Para realizar inferência, utiliza-se o método `generate`, que permite gerar texto de forma autoregressiva. Este método suporta diversas formas de decodificação, como greedy, beam search e amostragem 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
```

## Treinamento

Uma vez que o modelo é criado, ele pode ser ajustado de forma semelhante a BART, T5 ou qualquer outro modelo encoder-decoder em um conjunto de dados de pares (imagem, texto). Como você pode ver, apenas 2 entradas são necessárias para o modelo calcular uma perda: `pixel_values` (que são as imagens) e `labels` (que são os `input_ids` da sequência de destino 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 foi contribuído 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)
```

[Origem](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*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não.

encoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *opcional*) : O objeto de configuração ou dicionário do backbone do codificador.

decoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *opcional*) : O objeto de configuração ou dicionário do backbone do decoder.

Esta é a classe de configuração para armazenar a configuração de um Vision Encoder DecoderModel. Ela é usada para instanciar um modelo Vision Encoder Decoder de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [None](https://huggingface.co/None)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplos:

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

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

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

Uma instância de um objeto de configuração

Instancie um [VisionEncoderDecoderConfig](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig) (ou uma classe derivada) a partir de uma configuração de modelo de codificador pré-treinado e uma configuração de modelo de 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)
```

[Origem](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/pt/main_classes/configuration#transformers.PreTrainedConfig), *opcional*) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

encoder (`PreTrainedModel`, *opcional*) : O modelo de codificador a ser utilizado.

decoder (`PreTrainedModel`, *opcional*) : O modelo de decodificador a ser utilizado.

O modelo Vision Encoder Decoder puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](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*) : Os tensors correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando `image_processor_class`. Consulte `image_processor_class.__call__` para mais detalhes (`processor_class` usa `image_processor_class` para processar as imagens).

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são input IDs?](../glossary#input-ids) Se `past_key_values` for usado, opcionalmente apenas o último `decoder_input_ids` precisa ser inserido (veja `past_key_values`). Para treinamento, `decoder_input_ids` são criados automaticamente pelo modelo deslocando `labels` para a direita, substituindo -100 por `pad_token_id` e adicionando `decoder_start_token_id` no início.

decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão.

encoder_outputs (`tuple[torch.Tensor]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada para o decodificador. Os índices devem estar em `[-100, 0, ..., config.vocab_size]` (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)`

Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([VisionEncoderDecoderConfig](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)) e das entradas.

O método forward do [VisionEncoderDecoderModel](/docs/transformers/main/pt/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
- **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
- **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

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

[Origem](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*) : Informações necessárias para iniciar o codificador de imagem. Pode ser:  - Uma string, o *id do modelo* de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co. Um exemplo é `google/vit-base-patch16-224-in21k`. - Um caminho para um *diretório* contendo pesos de modelo salvos usando [save_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.save_pretrained), por exemplo, `./my_model_directory/`.

decoder_pretrained_model_name_or_path (`str`, *opcional*, padrão `None`) : Informações necessárias para iniciar o decodificador de texto. Pode ser:  - Uma string, o *model id* de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co. - Um caminho para um *diretório* contendo pesos de modelo salvos usando [save_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.save_pretrained), por exemplo, `./my_model_directory/`.

model_args (argumentos posicionais restantes, *opcional*) : Todos os argumentos posicionais restantes serão passados para o método `__init__` do modelo subjacente.

kwargs (dicionário restante de argumentos por palavra-chave, *opcional*) : Pode ser usado para atualizar o objeto de configuração (após ele ser carregado) e iniciar o modelo (por exemplo, `output_attentions=True`).  - Para atualizar a configuração do encoder, use o prefixo *encoder_* para cada parâmetro de configuração. - Para atualizar a configuração do decoder, use o prefixo *decoder_* para cada parâmetro de configuração. - Para atualizar a configuração do modelo principal, não use um prefixo para cada parâmetro de configuração.  O comportamento é diferente dependendo de uma `config` ser fornecida ou carregada automaticamente.

Instancie um codificador e um decodificador a partir de uma ou duas classes base da biblioteca, usando checkpoints de modelos pré-treinados.

O modelo é definido no modo de avaliação por padrão usando `model.eval()` (os módulos Dropout são desativados). Para treinar o modelo, é necessário primeiro redefinir o modo de treinamento com `model.train()`.

Exemplo:

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