# Mô hình Encoder Decoder thị giác

## Tổng quan

[VisionEncoderDecoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) có thể được sử dụng để khởi tạo một mô hình từ ảnh sang văn bản với bất kỳ mô hình thị giác Transformer nào đã được huấn luyện trước làm bộ mã hóa (*ví dụ* [ViT](vit), [BEiT](beit), [DeiT](deit), [Swin](swin)) và bất kỳ mô hình ngôn ngữ nào đã được huấn luyện trước làm bộ giải mã (*ví dụ* [RoBERTa](roberta), [GPT2](gpt2), [BERT](bert), [DistilBERT](distilbert)).

Hiệu quả của việc khởi tạo các mô hình từ ảnh sang chuỗi văn bản bằng các checkpoint được huấn luyện trước đã được chứng minh (chẳng hạn) trong [TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models](https://huggingface.co/papers/2109.10282) của Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei.

Sau khi một [VisionEncoderDecoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) như vậy được huấn luyện/tinh chỉnh, nó có thể được lưu/tải về giống như bất kỳ mô hình nào khác (xem các ví dụ bên dưới để biết thêm thông tin).

Một ứng dụng ví dụ là chú thích hình ảnh, trong đó bộ mã hóa được sử dụng để mã hóa hình ảnh, sau đó một mô hình ngôn ngữ tự hồi quy sẽ tạo ra chú thích. Một ví dụ khác là nhận dạng ký tự quang học. Tham khảo [TrOCR](trocr), đây là một trường hợp của [VisionEncoderDecoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel).

## Khởi tạo ngẫu nhiên `VisionEncoderDecoderModel` từ cấu hình mô hình

[VisionEncoderDecoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) có thể được khởi tạo ngẫu nhiên từ cấu hình encoder và cấu hình decoder. Trong ví dụ dưới đây, chúng ta sẽ xem cách thực hiện điều này bằng cách sử dụng cấu hình [ViTModel](/docs/transformers/v5.23.0/vi/model_doc/vit#transformers.ViTModel) mặc định cho encoder và cấu hình `BertForCausalLM` mặc định cho 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)
```

## Khởi tạo `VisionEncoderDecoderModel` từ một encoder được huấn luyện trước và một decoder được huấn luyện trước

[VisionEncoderDecoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) có thể được khởi tạo từ một checkpoint encoder đã được huấn luyện trước và một checkpoint decoder đã được huấn luyện trước. Lưu ý rằng bất kỳ mô hình thị giác nào dựa trên Transformer đã được huấn luyện trước, *ví dụ* [Swin](swin), đều có thể đóng vai trò là encoder và cả các mô hình tự mã hóa đã được huấn luyện trước, *ví dụ* BERT, các mô hình ngôn ngữ nhân quả đã được huấn luyện trước, *ví dụ* GPT2, cũng như phần decoder đã được huấn luyện trước của các mô hình sequence-to-sequence, *ví dụ* decoder của BART, đều có thể được sử dụng làm decoder. Tùy thuộc vào kiến trúc bạn chọn làm decoder, các lớp cross-attention có thể được khởi tạo ngẫu nhiên. Việc khởi tạo [VisionEncoderDecoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) từ checkpoint encoder và decoder đã được huấn luyện trước đòi hỏi mô hình phải được tinh chỉnh trên một tác vụ downstream, như đã được trình bày trong [bài đăng blog *Warm-starting-encoder-decoder*](https://huggingface.co/blog/warm-starting-encoder-decoder). Để làm điều này, lớp `VisionEncoderDecoderModel` cung cấp phương thức [VisionEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/v5.23.0/vi/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"
)
```

## Tải checkpoint `VisionEncoderDecoderModel` hiện có và thực hiện suy luận

Để nạp các checkpoint đã tinh chỉnh của lớp `VisionEncoderDecoderModel`, [VisionEncoderDecoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) cung cấp phương thức `from_pretrained(...)` giống như bất kỳ kiến trúc mô hình nào khác trong Transformers.

Để thực hiện suy luận, người ta sử dụng phương thức `generate`, cho phép tạo văn bản theo kiểu tự hồi quy. Phương thức này hỗ trợ nhiều dạng giải mã khác nhau, chẳng hạn như tham lam, tìm kiếm chùm và lấy mẫu đa thức.

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

## Huấn luyện

Sau khi mô hình được tạo, nó có thể được tinh chỉnh tương tự như BART, T5 hoặc bất kỳ mô hình encoder-decoder nào khác trên một tập dữ liệu gồm các cặp (image, text). Như bạn có thể thấy, mô hình chỉ cần 2 đầu vào để tính toán loss: `pixel_values` (là các hình ảnh) và `labels` (là `input_ids` của chuỗi đích đã được mã hóa).

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

Mô hình này được đóng góp bởi [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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_encoder_decoder/configuration_vision_encoder_decoder.py#L29)

**Tham số:**

is_encoder_decoder (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem mô hình có được sử dụng như một bộ mã hóa/giải mã hay không.

encoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *tùy chọn*) : Đối tượng config hoặc từ điển của encoder backbone.

decoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *tùy chọn*) : Đối tượng config hoặc từ điển của bộ khung decoder.

Đây là lớp cấu hình để lưu trữ cấu hình của một mô hình Vision Encoder Decoder. Nó được sử dụng để khởi tạo một mô hình Vision Encoder Decoder theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [None](https://huggingface.co/None)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_encoder_decoder/configuration_vision_encoder_decoder.py#L72)

**Trả về:** [VisionEncoderDecoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)

Một đối tượng cấu hình

Tạo một [VisionEncoderDecoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig) (hoặc một lớp kế thừa) từ cấu hình mô hình encoder và cấu hình mô hình decoder đã được huấn luyện trước.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L54)

**Tham số:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig), *optional*) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

encoder (`PreTrainedModel`, *tùy chọn*) : Mô hình encoder cần sử dụng.

decoder (`PreTrainedModel`, *tùy chọn*) : Mô hình decoder cần sử dụng.

Mô hình Vision Encoder Decoder cơ bản, xuất ra các hidden-state thô mà không có bất kỳ head cụ thể nào ở phía trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L301)

**Tham số:**

pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *tùy chọn*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng `image_processor_class`. Xem `image_processor_class.__call__` để biết chi tiết (`processor_class` sử dụng `image_processor_class` để xử lý ảnh).

decoder_input_ids (`torch.LongTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào của bộ giải mã trong từ vựng.  Các chỉ số có thể được lấy bằng cách sử dụng [PreTrainedTokenizer](/docs/transformers/v5.23.0/vi/main_classes/tokenizer#transformers.PythonBackend). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết.  [Input IDs là gì?](../glossary#input-ids)  Nếu `past_key_values` được sử dụng, tùy chọn chỉ cần nhập `decoder_input_ids` cuối cùng (xem `past_key_values`).  Đối với huấn luyện, `decoder_input_ids` được tạo tự động bởi mô hình bằng cách dịch chuyển `labels` sang phải, thay thế -100 bằng `pad_token_id` và thêm `decoder_start_token_id` vào đầu.

decoder_attention_mask (`torch.BoolTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Hành vi mặc định: tạo một tensor bỏ qua các token pad trong `decoder_input_ids`. Causal mask cũng sẽ được sử dụng theo mặc định.

encoder_outputs (`tuple[torch.Tensor]`, *tuỳ chọn*) : Tuple bao gồm (`last_hidden_state`, *tuỳ chọn*: `hidden_states`, *tuỳ chọn*: `attentions`) `last_hidden_state` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tuỳ chọn*) là một chuỗi các hidden-states tại đầu ra của lớp cuối cùng của encoder. Được sử dụng trong cross-attention của decoder.

past_key_values (`~cache_utils.Cache`, *tùy chọn*) : Các hidden-states đã tính trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng để tăng tốc giải mã tuần tự. Điều này thường bao gồm `past_key_values` do mô hình trả về ở một giai đoạn giải mã trước đó, khi `use_cache=True` hoặc `config.use_cache=True`.  Chỉ cho phép [Cache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.Cache) instance làm đầu vào, xem [hướng dẫn kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Nếu không truyền `past_key_values`, [DynamicCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.DynamicCache) sẽ được khởi tạo theo mặc định.  Mô hình sẽ xuất ra cùng định dạng cache được đưa vào làm đầu vào.  Nếu sử dụng `past_key_values`, người dùng được kỳ vọng chỉ nhập các `input_ids` chưa được xử lý (những phần chưa có trạng thái key value quá khứ được cung cấp cho mô hình này) có shape `(batch_size, unprocessed_length)` thay vì tất cả `input_ids` có shape `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, target_sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `decoder_input_ids`, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `decoder_input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

labels (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có mặt nạ cho bộ giải mã. Chỉ số nên nằm trong `[-100, 0, ..., config.vocab_size]` (xem docstring của `input_ids`) Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (có mặt nạ), tổn thất chỉ được tính cho các token có nhãn trong `[0, ..., config.vocab_size]`

use_cache (`bool`, *tùy chọn*) : Nếu được đặt thành `True`, các trạng thái khóa và giá trị `past_key_values` sẽ được trả về và có thể được sử dụng để tăng tốc quá trình giải mã (xem `past_key_values`).

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) hoặc `tuple(torch.Tensor)`

Một [Seq2SeqLMOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([VisionEncoderDecoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)) và đầu vào.

Phương thức forward của [VisionEncoderDecoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có shape `(1,)`, *tuỳ chọn*, được trả về khi `labels` được cung cấp) -- Loss của language modeling.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [EncoderDecoderCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.EncoderDecoderCache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi.

  Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention và trong các khối cross-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của bộ giải mã tại đầu ra của mỗi lớp cùng với đầu ra của nhúng ban đầu.
- **decoder_attentions** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention).
- **cross_attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý của lớp cross-attention của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý chéo.
- **encoder_last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các trạng thái ẩn tại đầu ra của lớp cuối cùng của bộ mã hóa trong mô hình.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của bộ mã hóa tại đầu ra của mỗi lớp cùng với đầu ra của nhúng ban đầu.
- **encoder_attentions** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý của bộ mã hóa, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự thân.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L155)

**Tham số:**

encoder_pretrained_model_name_or_path (`str`, *tùy chọn*) : Thông tin cần thiết để khởi tạo bộ mã hóa ảnh. Có thể là:  - Một chuỗi, *model id* của một mô hình được huấn luyện trước lưu trong kho mô hình trên huggingface.co. Một ví dụ là `google/vit-base-patch16-224-in21k`. - Một đường dẫn đến *thư mục* chứa trọng số mô hình được lưu bằng [save_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.save_pretrained), ví dụ: `./my_model_directory/`.

decoder_pretrained_model_name_or_path (`str`, *tùy chọn*, mặc định là `None`) : Thông tin cần thiết để khởi tạo bộ giải mã văn bản. Có thể là:  - Một chuỗi, *model id* của một mô hình được huấn luyện trước lưu trong kho mô hình trên huggingface.co. - Đường dẫn đến một *thư mục* chứa trọng số mô hình được lưu bằng [save_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.save_pretrained), ví dụ: `./my_model_directory/`.

model_args (các đối số vị trí còn lại, *tùy chọn*) : Tất cả các đối số vị trí còn lại sẽ được truyền đến phương thức `__init__` của model cơ sở.

kwargs (các đối số từ điển còn lại, *tùy chọn*) : Có thể được sử dụng để cập nhật đối tượng cấu hình (sau khi nó được tải) và khởi tạo mô hình (ví dụ: `output_attentions=True`).  - Để cập nhật cấu hình encoder, hãy sử dụng tiền tố *encoder_* cho mỗi tham số cấu hình. - Để cập nhật cấu hình decoder, hãy sử dụng tiền tố *decoder_* cho mỗi tham số cấu hình. - Để cập nhật cấu hình của mô hình cha, không sử dụng tiền tố cho mỗi tham số cấu hình.  Hoạt động khác nhau tùy thuộc vào việc có cung cấp `config` hay được tải tự động.

Tạo một encoder và một decoder từ một hoặc hai lớp cơ bản của thư viện từ các checkpoint mô hình được huấn luyện trước.

Mô hình mặc định được đặt ở chế độ đánh giá bằng `model.eval()` (các module Dropout bị vô hiệu hóa). Để huấn luyện mô hình, bạn cần đặt lại nó về chế độ huấn luyện bằng `model.train()`.

Ví dụ:

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