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→