Transformers 文件

視覺編碼器-解碼器模型

Transformers

加入 Hugging Face 社群

並獲得增強的文件體驗

在模型、資料集和 Spaces 上進行協作

透過加速推理獲得更快的示例

切換文件主題

開始使用

視覺編碼器-解碼器模型

概述

VisionEncoderDecoderModel 可用於使用任何預訓練的基於 Transformer 的視覺模型作為編碼器（例如 ViT、BEiT、DeiT、Swin）和任何預訓練的語言模型作為解碼器（例如 RoBERTa、GPT2、BERT、DistilBERT）來初始化影像到文字模型。

透過預訓練檢查點初始化影像到文字序列模型的有效性已在（例如）Minghao Li、Tengchao Lv、Lei Cui、Yijuan Lu、Dinei Florencio、Cha Zhang、Zhoujun Li、Furu Wei 的 TrOCR: 基於 Transformer 的預訓練模型光學字元識別中得到證實。

經過訓練/微調後，此 VisionEncoderDecoderModel 可以像其他任何模型一樣儲存/載入（有關更多資訊，請參閱下面的示例）。

一個示例應用是影像字幕，其中編碼器用於編碼影像，之後自迴歸語言模型生成字幕。另一個示例是光學字元識別。請參閱 TrOCR，它是 VisionEncoderDecoderModel 的一個例項。

從模型配置隨機初始化 VisionEncoderDecoderModel。

VisionEncoderDecoderModel 可以從編碼器和解碼器配置隨機初始化。在下面的示例中，我們展示瞭如何使用預設的 ViTModel 配置作為編碼器，以及預設的 BertForCausalLM 配置作為解碼器來完成此操作。

>>> from transformers import BertConfig, ViTConfig, VisionEncoderDecoderConfig, VisionEncoderDecoderModel

>>> config_encoder = ViTConfig()
>>> config_decoder = BertConfig()

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

從預訓練的編碼器和預訓練的解碼器初始化 VisionEncoderDecoderModel。

VisionEncoderDecoderModel 可以從預訓練的編碼器檢查點和預訓練的解碼器檢查點初始化。請注意，任何預訓練的基於 Transformer 的視覺模型，例如 Swin，都可以用作編碼器，並且預訓練的自編碼模型（例如 BERT）、預訓練的因果語言模型（例如 GPT2）以及序列到序列模型的預訓練解碼器部分（例如 BART 的解碼器）都可以用作解碼器。根據您選擇作為解碼器的架構，交叉注意力層可能會隨機初始化。從預訓練的編碼器和解碼器檢查點初始化 VisionEncoderDecoderModel 需要對下游任務進行微調，如“Warm-starting-encoder-decoder”部落格文章所示。為此，VisionEncoderDecoderModel 類提供了 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"
... )

載入現有 VisionEncoderDecoderModel 檢查點並執行推理。

要載入 VisionEncoderDecoderModel 類的微調檢查點，VisionEncoderDecoderModel 像 Transformers 中的任何其他模型架構一樣提供 from_pretrained(...) 方法。

要執行推理，可以使用 `generate` 方法，該方法允許自迴歸生成文字。此方法支援各種解碼形式，例如貪婪解碼、束搜尋和多項式取樣。

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

將 PyTorch 檢查點載入到 TFVisionEncoderDecoderModel 中。

TFVisionEncoderDecoderModel.from_pretrained() 目前不支援從 PyTorch 檢查點初始化模型。將 from_pt=True 傳遞給此方法將引發異常。如果特定視覺編碼器-解碼器模型只有 PyTorch 檢查點，解決方法是

>>> from transformers import VisionEncoderDecoderModel, TFVisionEncoderDecoderModel

>>> _model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning")

>>> _model.encoder.save_pretrained("./encoder")
>>> _model.decoder.save_pretrained("./decoder")

>>> model = TFVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "./encoder", "./decoder", encoder_from_pt=True, decoder_from_pt=True
... )
>>> # This is only for copying some specific attributes of this particular model.
>>> model.config = _model.config

訓練

模型建立後，可以在（影像，文字）對資料集上進行微調，類似於 BART、T5 或任何其他編碼器-解碼器模型。如您所見，模型只需要 2 個輸入即可計算損失：pixel_values（即影像）和 labels（即編碼目標序列的 input_ids）。

>>> from transformers import ViTImageProcessor, BertTokenizer, VisionEncoderDecoderModel
>>> from datasets import load_dataset

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

此模型由 nielsr 貢獻。此模型的 TensorFlow 和 Flax 版本由 ydshieh 貢獻。

VisionEncoderDecoderConfig

類 transformers.VisionEncoderDecoderConfig

< 來源 >

( **kwargs )

引數

kwargs (可選) — 關鍵字引數字典。特別指出：
- encoder (PretrainedConfig, 可選) — 定義編碼器配置的配置物件例項。
- decoder (PretrainedConfig, 可選) — 定義解碼器配置的配置物件例項。

VisionEncoderDecoderConfig 是用於儲存 VisionEncoderDecoderModel 配置的配置類。它用於根據指定的引數（定義編碼器和解碼器配置）例項化視覺-編碼器-文字-解碼器模型。

配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 的文件。

示例

>>> from transformers import BertConfig, ViTConfig, VisionEncoderDecoderConfig, VisionEncoderDecoderModel

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

>>> config = VisionEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, 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: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → VisionEncoderDecoderConfig

VisionEncoderDecoderConfig

一個配置物件的例項

從預訓練的編碼器模型配置和解碼器模型配置例項化 VisionEncoderDecoderConfig（或派生類）。

Pytorch

隱藏 Pytorch 內容

VisionEncoderDecoderModel

類 transformers.VisionEncoderDecoderModel

< 來源 >

( config: typing.Optional[transformers.configuration_utils.PretrainedConfig] = None encoder: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None decoder: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None )

引數

config (PretrainedConfig, 可選) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法以載入模型權重。
encoder (PreTrainedModel, 可選) — 要使用的編碼器模型。
decoder (PreTrainedModel, 可選) — 要使用的解碼器模型。

裸 Vision Encoder Decoder 模型，輸出原始隱藏狀態，頂部沒有任何特定頭部。

此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。

此模型也是 PyTorch torch.nn.Module 子類。請將其用作常規 PyTorch 模組，並參考 PyTorch 文件中有關通用用法和行為的所有事項。

forward

< 來源 >

( pixel_values: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None encoder_outputs: typing.Optional[tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

引數

pixel_values (torch.FloatTensor，形狀為 (batch_size, num_channels, image_size, image_size)，可選) — 對應於輸入影像的張量。畫素值可以使用 {image_processor_class} 獲取。有關詳細資訊，請參閱 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 處理影像）。
decoder_input_ids (torch.LongTensor，形狀為 (batch_size, target_sequence_length)，可選) — 解碼器輸入序列詞彙表中的 token 索引。

索引可以使用 PreTrainedTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什麼是輸入 ID？

如果使用 past_key_values，可選地只需輸入最後的 decoder_input_ids（那些沒有將其過去的鍵值狀態提供給此模型的）（參見 past_key_values）。

對於訓練，decoder_input_ids 由模型透過將 labels 右移，將 -100 替換為 pad_token_id 並在其前面加上 decoder_start_token_id 自動建立。
decoder_attention_mask (torch.BoolTensor，形狀為 (batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略 decoder_input_ids 中填充 token 的張量。預設情況下也將使用因果掩碼。
encoder_outputs (tuple[torch.FloatTensor]，可選) — 元組包含 (last_hidden_state, 可選: hidden_states, 可選: attentions) last_hidden_state 形狀為 (batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。在解碼器的交叉注意力中使用。
past_key_values (tuple[tuple[torch.FloatTensor]], 可選) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼上一階段返回的 past_key_values，當 use_cache=True 或 config.use_cache=True 時。

允許兩種格式：
- Cache 例項，請參閱我們的 kv 快取指南；
- 長度為 config.n_layers 的 tuple(torch.FloatTensor) 元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量）。這也被稱為舊版快取格式。
模型將輸出與作為輸入提供的快取格式相同的快取格式。如果未傳遞 past_key_values，將返回舊版快取格式。

如果使用 past_key_values，使用者可以選擇僅輸入最後一個 input_ids（那些沒有將其過去鍵值狀態提供給此模型的），形狀為 (batch_size, 1)，而不是所有 input_ids，形狀為 (batch_size, sequence_length)。
decoder_inputs_embeds (torch.FloatTensor，形狀為 (batch_size, target_sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞 decoder_input_ids。如果您希望對如何將 decoder_input_ids 索引轉換為關聯向量有更多控制，而不是模型的內部嵌入查詢矩陣，這將非常有用。
labels (torch.LongTensor，形狀為 (batch_size, sequence_length)，可選) — 用於計算解碼器蒙版語言建模損失的標籤。索引應在 [-100, 0, ..., config.vocab_size] 之間（參見 input_ids 文件字串），索引設定為 -100 的 token 將被忽略（蒙版），損失僅針對標籤在 [0, ..., config.vocab_size] 範圍內的 token 進行計算。
use_cache (bool, 可選) — 如果設定為 True，將返回 past_key_values 鍵值狀態，可用於加速解碼（參見 past_key_values）。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。
return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。

transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_outputs.Seq2SeqLMOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (VisionEncoderDecoderConfig) 和輸入而定的各種元素。

loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 語言建模損失。
logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。
past_key_values (EncoderDecoderCache, 可選, 當 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 EncoderDecoderCache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。

包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。
decoder_hidden_states (tuple(torch.FloatTensor), 可選, 當 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 元組（如果模型有嵌入層，則一個用於嵌入輸出，加上一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
decoder_attentions (tuple(torch.FloatTensor), 可選, 當 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
cross_attentions (tuple(torch.FloatTensor), 可選, 當 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
encoder_last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
encoder_hidden_states (tuple(torch.FloatTensor), 可選, 當 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 元組（如果模型有嵌入層，則一個用於嵌入輸出，加上一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
encoder_attentions (tuple(torch.FloatTensor), 可選, 當 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

VisionEncoderDecoderModel 的前向傳播方法，重寫了 __call__ 特殊方法。

雖然前向傳播的實現需要在該函式中定義，但在此之後應呼叫 Module 例項，因為前者負責執行預處理和後處理步驟，而後者會默默忽略它們。

示例

>>> from transformers import AutoProcessor, VisionEncoderDecoderModel
>>> import requests
>>> 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"
>>> image = Image.open(requests.get(url, stream=True).raw).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: typing.Optional[str] = None decoder_pretrained_model_name_or_path: typing.Optional[str] = None *model_args **kwargs )

引數

encoder_pretrained_model_name_or_path (str, 可選) — 初始化影像編碼器所需的資訊。可以是以下之一：
- 一個字串，即託管在 huggingface.co 上的模型倉庫中的預訓練模型的模型 ID。例如 google/vit-base-patch16-224-in21k。
- 一個目錄的路徑，包含使用 save_pretrained() 儲存的模型權重，例如 ./my_model_directory/。
- 一個Tensorflow 索引檢查點檔案的路徑或 URL（例如，./tf_model/model.ckpt.index）。在這種情況下，應將 from_tf 設定為 True，並提供一個配置物件作為 config 引數。此載入路徑比使用提供的轉換指令碼將 TensorFlow 檢查點轉換為 PyTorch 模型，然後載入 PyTorch 模型要慢。
decoder_pretrained_model_name_or_path (str, 可選, 預設為 None) — 初始化文字解碼器所需的資訊。可以是以下之一：
- 一個字串，即託管在huggingface.co模型倉庫中的預訓練模型的模型 ID。
- 一個目錄的路徑，該目錄包含使用save_pretrained()儲存的模型權重，例如 ./my_model_directory/。
- 一個tensorflow 索引檢查點檔案的路徑或 URL（例如，./tf_model/model.ckpt.index）。在這種情況下，from_tf應設定為True，並且應提供配置物件作為config引數。這種載入路徑比使用提供的轉換指令碼將TensorFlow檢查點轉換為PyTorch模型，然後載入PyTorch模型更慢。
model_args (剩餘的位置引數，可選) — 所有剩餘的位置引數將傳遞給底層模型的 __init__ 方法。
kwargs (剩餘的關鍵字引數字典，可選) — 可用於更新配置物件（載入後）並初始化模型（例如，output_attentions=True）。
- 要更新編碼器配置，請為每個配置引數使用字首 encoder_。
- 要更新解碼器配置，請為每個配置引數使用字首 decoder_。
- 要更新父模型配置，請勿為每個配置引數使用字首。
行為因是否提供了 config 或自動載入而異。

從庫的一個或兩個基類例項化一個編碼器和一個解碼器，這些基類來自預訓練的模型檢查點。

模型預設使用 model.eval() 設定為評估模式（Dropout 模組已停用）。要訓練模型，您需要首先使用 model.train() 將其設定回訓練模式。

示例

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

TensorFlow

隱藏 TensorFlow 內容

TFVisionEncoderDecoderModel

class transformers.TFVisionEncoderDecoderModel

< source >

( config: Optional[PretrainedConfig] = None encoder: Optional[TFPreTrainedModel] = None decoder: Optional[TFPreTrainedModel] = None )

引數

config (VisionEncoderDecoderConfig) — 包含模型所有引數的模型配置類。用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法載入模型權重。

該類可用於初始化影像到文字序列模型，其中任何預訓練視覺自編碼模型作為編碼器，任何預訓練文字自迴歸模型作為解碼器。編碼器透過 from_pretrained() 函式載入，解碼器透過 from_pretrained() 函式載入。交叉注意力層會自動新增到解碼器中，並且應在下游生成任務（如影像描述生成）上進行微調。

Sascha Rothe、Shashi Narayan、Aliaksei Severyn、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 在 Leveraging Pre-trained Checkpoints for Sequence Generation Tasks 中展示了使用預訓練檢查點初始化序列生成任務的序列到序列模型的有效性。

此外，在 TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models 中展示瞭如何利用大型預訓練視覺模型進行光學字元識別 (OCR) 從而顯著提高效能。

經過訓練/微調的 Vision-Encoder-Text-Decoder 模型可以像其他模型一樣儲存/載入（更多資訊請參閱示例）。

該模型繼承自 TFPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）的更多資訊，請檢視超類文件。

此模型也是 keras.Model 的子類。將其作為常規 TF 2.0 Keras 模型使用，並參閱 TF 2.0 文件瞭解所有與一般用法和行為相關的事項。

TFVisionEncoderDecoderModel 是一個通用模型類，當使用 from_pretrained() 類方法作為編碼器和 from_pretrained() 類方法作為解碼器建立時，它將被例項化為一種變壓器架構，其中庫的一個基本視覺模型類作為編碼器，另一個作為解碼器。

呼叫

< source >

( pixel_values: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: Optional[Union[tuple, TFBaseModelOutput]] = None past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False **kwargs ) → transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)

引數

pixel_values (np.ndarray, tf.Tensor, list[tf.Tensor] `dict[str, tf.Tensor] 或 dict[str, np.ndarray]，每個示例的形狀必須為 (batch_size, num_channels, height, width)) — 畫素值。畫素值可以使用視覺模型的影像處理器獲取。例如，使用 AutoImageProcessor。有關詳細資訊，請參閱 ViTImageProcessor.call()。
decoder_input_ids (np.ndarray 或 tf.Tensor 形狀為 (batch_size, target_sequence_length)，可選) — 解碼器輸入序列中詞彙表的標記索引。

索引可以使用 PreTrainedTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什麼是輸入 ID？

如果使用了 past_key_values，則可選擇僅輸入最後一個 decoder_input_ids（那些未將其過去的鍵值狀態提供給此模型的）的形狀 (batch_size, 1)，而不是所有 (batch_size, sequence_length) 形狀的 decoder_input_ids。

提供給解碼器用於序列到序列訓練。索引可以使用 PreTrainedTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
decoder_attention_mask (np.ndarray 或 tf.Tensor 形狀為 (batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略 decoder_input_ids 中填充標記的張量。預設情況下也會使用因果掩碼。
encoder_outputs (tuple(tuple(tf.Tensor)，可選) — 此元組必須由 (last_hidden_state, 可選: hidden_states, 可選: attentions) 組成。last_hidden_state (tf.Tensor 形狀為 (batch_size, sequence_length, hidden_size)) 是編碼器最後一層輸出的隱藏狀態張量。用於解碼器的交叉注意力。
past_key_values (tuple(tuple(tf.Tensor)) 長度為 config.n_layers，每個元組包含 4 個形狀為 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的張量) — 包含預計算的注意力塊的鍵值隱藏狀態。可用於加速解碼。

如果使用 past_key_values，使用者可以選擇只輸入最後一個 decoder_input_ids（那些沒有將其過去的鍵值狀態提供給此模型的），形狀為 (batch_size, 1)，而不是所有 (batch_size, sequence_length) 形狀的 decoder_input_ids。
decoder_inputs_embeds (np.ndarray 或 tf.Tensor 形狀為 (batch_size, target_sequence_length, hidden_size)，可選) — 可選地，您可以透過直接傳遞嵌入表示來代替傳遞 decoder_input_ids。如果您希望對 decoder_input_ids 索引如何轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制，這將非常有用。
labels (np.ndarray 或 tf.Tensor 形狀為 (batch_size, sequence_length)，可選) — 用於計算解碼器掩碼語言模型損失的標籤。索引應在 [-100, 0, ..., config.vocab_size] 範圍內（請參閱 input_ids 文件字串）。索引設定為 -100 的標記將被忽略（掩碼），損失僅針對標籤在 [0, ..., config.vocab_size] 範圍內的標記計算。
use_cache (bool, 可選) — 如果設定為 True，則返回 past_key_values 鍵值狀態，可用於加速解碼（請參閱 past_key_values）。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。
return_dict (bool, 可選) — 如果設定為 True，模型將返回一個 ~utils.Seq2SeqLMOutput 而不是一個普通元組。
training (bool, 可選, 預設為 False) — 是否在訓練模式下使用模型（某些模組，如 dropout 模組在訓練和評估之間有不同的行為）。
kwargs (可選) — 剩餘的關鍵字引數字典。關鍵字引數有兩種形式：
- 不帶字首，將作為 **encoder_kwargs 輸入給編碼器前向函式。
- 帶 decoder_ 字首，將作為 **decoder_kwargs 輸入給解碼器前向函式。

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一個 tf.Tensor 的元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (VisionEncoderDecoderConfig) 和輸入而變化的各種元素。

loss (形狀為 (n,) 的 tf.Tensor, 可選, 其中 n 是非掩碼標籤的數量，當提供 labels 時返回) — 語言建模損失。
logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前每個詞彙標記的分數）。
past_key_values (list[tf.Tensor], 可選, 當傳入 use_cache=True 或當 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。
decoder_hidden_states (tuple(tf.Tensor), 可選, 當傳入 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入輸出 + 每個層輸出一個），形狀為 (batch_size, sequence_length, hidden_size)。

解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
decoder_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或當 config.output_attentions=True 時返回) — tf.Tensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
cross_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或當 config.output_attentions=True 時返回) — tf.Tensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
encoder_hidden_states (tuple(tf.Tensor), 可選, 當傳入 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入輸出 + 每個層輸出一個），形狀為 (batch_size, sequence_length, hidden_size)。

編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
encoder_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或當 config.output_attentions=True 時返回) — tf.Tensor 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

The TFVisionEncoderDecoderModel forward 方法，覆蓋了 __call__ 特殊方法。

雖然前向傳播的實現需要在該函式中定義，但在此之後應呼叫 Module 例項，因為前者負責執行預處理和後處理步驟，而後者會默默忽略它們。

示例

>>> from transformers import AutoImageProcessor, AutoTokenizer, TFVisionEncoderDecoderModel
>>> from PIL import Image
>>> import requests

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
>>> decoder_tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")

>>> # initialize a bert2gpt2 from a pretrained BERT and GPT2 models. Note that the cross-attention layers will be randomly initialized
>>> model = TFVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "openai-community/gpt2"
... )

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> img = Image.open(requests.get(url, stream=True).raw)

>>> # forward
>>> pixel_values = image_processor(images=img, return_tensors="tf").pixel_values  # Batch size 1
>>> decoder_input_ids = decoder_tokenizer("Linda Davis", return_tensors="tf").input_ids  # Batch size 1
>>> outputs = model(pixel_values=pixel_values, decoder_input_ids=decoder_input_ids)

>>> # training
>>> outputs = model(pixel_values=pixel_values, decoder_input_ids=decoder_input_ids, labels=decoder_input_ids)
>>> loss, logits = outputs.loss, outputs.logits

>>> # save and load from pretrained
>>> model.save_pretrained("vit-gpt2")
>>> model = TFVisionEncoderDecoderModel.from_pretrained("vit-gpt2")

>>> # generation
>>> generated = model.generate(pixel_values, decoder_start_token_id=model.config.decoder.bos_token_id)

from_encoder_decoder_pretrained

< source >

( encoder_pretrained_model_name_or_path: Optional[str] = None decoder_pretrained_model_name_or_path: Optional[str] = None *model_args **kwargs )

引數

encoder_pretrained_model_name_or_path (str, 可選) — 初始化編碼器所需的資訊。可以是以下之一：
- 一個字串，即託管在huggingface.co模型倉庫中的預訓練模型的模型 ID。例如 google/vit-base-patch16-224-in21k。
- 一個目錄的路徑，該目錄包含使用save_pretrained()儲存的模型權重，例如 ./my_model_directory/。
- 一個pytorch 索引檢查點檔案的路徑或 URL（例如，./pt_model/）。在這種情況下，encoder_from_pt應設定為True。
decoder_pretrained_model_name_or_path (str, 可選, 預設為 None) — 初始化解碼器所需的資訊。可以是以下之一：
- 一個字串，即託管在huggingface.co模型倉庫中的預訓練模型的模型 ID。
- 一個目錄的路徑，該目錄包含使用save_pretrained()儲存的模型權重，例如 ./my_model_directory/。
- 一個pytorch 檢查點檔案的路徑或 URL（例如，./pt_model/）。在這種情況下，decoder_from_pt應設定為True。
model_args (剩餘的位置引數，可選) — 所有剩餘的位置引數將傳遞給底層模型的 __init__ 方法。
kwargs (剩餘的關鍵字引數字典，可選) — 可用於更新配置物件（載入後）並初始化模型（例如，output_attentions=True）。
- 要更新編碼器配置，請為每個配置引數使用字首 encoder_。
- 要更新解碼器配置，請為每個配置引數使用字首 decoder_。
- 要更新父模型配置，請勿為每個配置引數使用字首。
行為因是否提供了 config 或自動載入而異。

從庫的一個或兩個基類例項化一個編碼器和一個解碼器，這些基類來自預訓練的模型檢查點。

示例

>>> from transformers import TFVisionEncoderDecoderModel

>>> # initialize a vit-bert from a pretrained ViT and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = TFVisionEncoderDecoderModel.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 = TFVisionEncoderDecoderModel.from_pretrained("./vit-bert")

JAX

隱藏 JAX 內容

FlaxVisionEncoderDecoderModel

class transformers.FlaxVisionEncoderDecoderModel

< source >

( config: VisionEncoderDecoderConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

引數

config (VisionEncoderDecoderConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法載入模型權重。
dtype (jax.numpy.dtype, 可選, 預設為 jax.numpy.float32) — 計算的資料型別。可以是 jax.numpy.float32、jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的 dtype 執行。

請注意，這隻指定了計算的資料型別，不影響模型引數的資料型別。

如果您希望更改模型引數的資料型別，請參閱 to_fp16() 和 to_bf16()。

此外，在 TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models 中展示瞭如何利用大型預訓練視覺模型進行光學字元識別 (OCR) 從而顯著提高效能。

經過訓練/微調的 Vision-Encoder-Text-Decoder 模型可以像其他模型一樣儲存/載入（更多資訊請參閱示例）。

該模型繼承自 FlaxPreTrainedModel。有關庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）的更多資訊，請檢視超類文件。

此模型也是 Flax Linen flax.nn.Module 的子類。將其作為常規 Flax 模組使用，並參閱 Flax 文件瞭解所有與一般用法和行為相關的事項。

FlaxVisionEncoderDecoderModel 是一個通用模型類，當使用 :meth~transformers.FlaxAutoModel.from_pretrained 類方法作為編碼器模組和 :meth~transformers.FlaxAutoModelForCausalLM.from_pretrained 類方法作為解碼器模組建立時，它將被例項化為一種變壓器架構，其中庫的一個基本視覺模型類作為編碼器模組，另一個作為解碼器模組。

call

< source >

( pixel_values: Array decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

引數

pixel_values (jnp.ndarray 形狀為 (batch_size, num_channels, height, width)) — 畫素值。畫素值可以使用視覺模型的影像處理器獲取。例如，使用 AutoImageProcessor。有關詳細資訊，請參閱 ViTImageProcessor.call()。
decoder_input_ids (jnp.ndarray 形狀為 (batch_size, target_sequence_length)，可選) — 解碼器輸入序列中詞彙表的標記索引。

索引可以使用 PreTrainedTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什麼是解碼器輸入 ID？
decoder_attention_mask (jnp.ndarray 形狀為 (batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略 decoder_input_ids 中填充標記的張量。預設情況下也會使用因果掩碼。
decoder_position_ids (jnp.ndarray 形狀為 (batch_size, sequence_length)，可選) — 解碼器輸入序列中每個標記在位置嵌入中的位置索引。選擇範圍為 [0, config.decoder.max_position_embeddings - 1]。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 attentions。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 hidden_states。
return_dict (bool, 可選) — 如果設定為 True，模型將返回一個 ~utils.FlaxSeq2SeqLMOutput 而不是一個普通元組。

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

一個 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (VisionEncoderDecoderConfig) 和輸入而變化的各種元素。

logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。
past_key_values (tuple(tuple(jnp.ndarray)), 可選, 當傳入use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的tuple(tuple(jnp.ndarray))元組，其中每個元組包含2個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量，以及2個形狀為(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的額外張量。

包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。
decoder_hidden_states (tuple(jnp.ndarray), 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — jnp.ndarray元組 (一個用於嵌入層輸出 + 一個用於每個解碼器層的輸出)，形狀為(batch_size, sequence_length, hidden_size)。

解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
decoder_attentions (tuple(jnp.ndarray), 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — jnp.ndarray元組 (每個解碼器層一個)，形狀為(batch_size, num_heads, sequence_length, sequence_length)。

解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
cross_attentions (tuple(jnp.ndarray), 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — jnp.ndarray元組 (每個解碼器層一個)，形狀為(batch_size, num_heads, sequence_length, sequence_length)。

解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
encoder_hidden_states (tuple(jnp.ndarray), 可選, 當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — jnp.ndarray元組 (一個用於嵌入層輸出 + 一個用於每個編碼器層的輸出)，形狀為(batch_size, sequence_length, hidden_size)。

編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
encoder_attentions (tuple(jnp.ndarray), 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) — jnp.ndarray元組 (每個編碼器層一個)，形狀為(batch_size, num_heads, sequence_length, sequence_length)。

編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

FlaxVisionEncoderDecoderModel 的 forward 方法，重寫了 __call__ 特殊方法。

雖然前向傳播的實現需要在該函式中定義，但在此之後應呼叫 Module 例項，因為前者負責執行預處理和後處理步驟，而後者會默默忽略它們。

示例

>>> from transformers import FlaxVisionEncoderDecoderModel, AutoImageProcessor, AutoTokenizer
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")

>>> # load output tokenizer
>>> tokenizer_output = AutoTokenizer.from_pretrained("openai-community/gpt2")

>>> # initialize a vit-gpt2 from pretrained ViT and GPT2 models. Note that the cross-attention layers will be randomly initialized
>>> model = FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "openai-community/gpt2"
... )

>>> pixel_values = image_processor(images=image, return_tensors="np").pixel_values

>>> # use GPT2's eos_token as the pad as well as eos token
>>> model.config.eos_token_id = model.config.decoder.eos_token_id
>>> model.config.pad_token_id = model.config.eos_token_id

>>> # generation
>>> sequences = model.generate(pixel_values, num_beams=4, max_length=12).sequences

>>> captions = tokenizer_output.batch_decode(sequences, skip_special_tokens=True)

from_encoder_decoder_pretrained

< source >

( encoder_pretrained_model_name_or_path: typing.Union[str, os.PathLike, NoneType] = None decoder_pretrained_model_name_or_path: typing.Union[str, os.PathLike, NoneType] = None *model_args **kwargs )

引數

encoder_pretrained_model_name_or_path (Union[str, os.PathLike], 可選) — 初始化編碼器所需的資訊。可以是以下之一：
- 一個字串，是託管在huggingface.co上的模型倉庫中的預訓練模型的模型ID。例如google/vit-base-patch16-224-in21k。
- 一個包含使用save_pretrained()儲存的模型權重的目錄路徑，例如./my_model_directory/。
decoder_pretrained_model_name_or_path (Union[str, os.PathLike], 可選, 預設為None) — 初始化解碼器所需的資訊。可以是以下之一：
- 一個字串，是託管在huggingface.co上的模型倉庫中的預訓練模型的模型ID。
- 一個包含使用save_pretrained()儲存的模型權重的目錄路徑，例如./my_model_directory/。
model_args (剩餘位置引數，可選) — 所有剩餘的位置引數將傳遞給底層模型的__init__方法。
kwargs (剩餘的關鍵字引數字典，可選) — 可用於更新配置物件 (載入後) 並初始化模型 (例如，output_attentions=True)。
- 要更新編碼器配置，請為每個配置引數使用字首encoder_。
- 要更新解碼器配置，請為每個配置引數使用字首decoder_。
- 要更新父模型配置，請不要為每個配置引數使用字首。
根據是否提供了config或是否自動載入，行為會有所不同。

從庫的一個或兩個基類例項化一個編碼器和一個解碼器，這些基類來自預訓練的模型檢查點。

示例

>>> from transformers import FlaxVisionEncoderDecoderModel

>>> # initialize a vit-gpt2 from a pretrained ViT and a pretrained GPT2 model. Note that the cross-attention layers will be randomly initialized
>>> model = FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "openai-community/gpt2"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-gpt2")
>>> # load fine-tuned model
>>> model = FlaxVisionEncoderDecoderModel.from_pretrained("./vit-gpt2")

< > 在 GitHub 上更新

←VipLlava Vision Text Dual Encoder→