视觉编码器-解码器模型

概述

VisionEncoderDecoderModel 可用于初始化图像到文本模型，使用任何预训练的基于 Transformer 的视觉模型作为编码器 (例如 ViT, BEiT, DeiT, Swin) 和任何预训练的语言模型作为解码器 (例如 RoBERTa, GPT2, BERT, DistilBERT)。

使用预训练检查点初始化图像到文本序列模型的有效性已在 (例如) TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models by Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei 中得到证明。

在这样的 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 提供了 from_pretrained(...) 方法，就像 Transformers 中的任何其他模型架构一样。

要执行推理，可以使用 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

class 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

< source >

( encoder_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → VisionEncoderDecoderConfig

返回值

VisionEncoderDecoderConfig

配置对象的实例

从预训练的编码器模型配置和解码器模型配置实例化一个 VisionEncoderDecoderConfig（或派生类）。

Pytorch

隐藏 Pytorch 内容

VisionEncoderDecoderModel

class transformers.VisionEncoderDecoderModel

< source >

( 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 (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 模型后，它可以像任何其他模型一样被保存/加载（有关更多信息，请参见示例）。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参阅 PyTorch 文档以了解与一般用法和行为相关的所有事项。

VisionEncoderDecoderModel 是一个通用模型类，当使用编码器的 :meth~transformers.AutoModel.from_pretrained 类方法和解码器的 :meth~transformers.AutoModelForCausalLM.from_pretrained 类方法创建时，它将被实例化为具有库的基础视觉模型类之一作为编码器，另一个作为解码器的 transformer 架构。

forward

< source >

( 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[typing.Tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[typing.Tuple[typing.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 (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。像素值可以使用图像处理器获得（例如，如果您使用 ViT 作为编码器，则应使用 AutoImageProcessor）。有关详细信息，请参见 ViTImageProcessor.call()。
decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 torch.LongTensor, 可选) — 词汇表中解码器输入序列标记的索引。

索引可以使用 PreTrainedTokenizer 获得。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？

如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids（请参阅 past_key_values）。

对于训练，decoder_input_ids 由模型自动创建，方法是将 labels 向右移动，用 pad_token_id 替换 -100，并在它们前面加上 decoder_start_token_id。
decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 torch.BoolTensor, 可选) — 默认行为：生成一个张量，该张量忽略 decoder_input_ids 中的 pad 标记。默认情况下也将使用因果掩码。
encoder_outputs (tuple(torch.FloatTensor), 可选) — 此元组必须包含 (last_hidden_state, 可选: hidden_states, 可选: attentions)。last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) 是编码器最后一层的输出处的隐藏状态张量。在解码器的交叉注意力中使用。
past_key_values (长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor))，其中每个元组有 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 (形状为 (batch_size, target_sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 或者，您可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果您希望更好地控制如何将 decoder_input_ids 索引转换为关联的向量，而不是模型的内部嵌入查找矩阵，这将非常有用。
labels (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 用于计算解码器的掩码语言建模损失的标签。索引应在 [-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 而不是普通元组。
kwargs (可选) — 关键字参数的剩余字典。关键字参数有两种形式：
- 没有前缀的关键字参数将作为 **encoder_kwargs 输入到编码器 forward 函数中。
- 带有 decoder_ 前缀的关键字参数将作为 **decoder_kwargs 输入到解码器 forward 函数中。

返回值

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

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (VisionEncoderDecoderConfig) 和输入。

loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 语言建模损失。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇表标记的分数）。
past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor)) 元组，其中每个元组有 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(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 (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 模型编码器的最后一层输出处的隐藏状态序列。
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 forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但应该在此之后调用 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

< source >

( encoder_pretrained_model_name_or_path: str = None decoder_pretrained_model_name_or_path: 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

< 源代码 >

( config: 可选的[PretrainedConfig] = None encoder: 可选的[TFPreTrainedModel] = None decoder: 可选的[TFPreTrainedModel] = None )

参数

config (VisionEncoderDecoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

此外，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() 类方法为解码器创建时，它将实例化为一个 Transformer 架构，其中库的一个基本视觉模型类作为编码器，另一个基本模型类作为解码器。

调用

< 源代码 >

( 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: 可选的[Union[Tuple, TFBaseModelOutput]] = None past_key_values: 可选的[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: 可选的[bool] = None output_attentions: 可选的[bool] = None output_hidden_states: 可选的[bool] = None return_dict: 可选的[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（请参阅 past_key_values）。

为解码器提供序列到序列训练。索引可以使用 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 (形状为 (batch_size, sequence_length, config.vocab_size) 的 tf.Tensor) — 语言建模头的预测得分（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 之后，用于计算自注意力头中的加权平均值。

TFVisionEncoderDecoderModel 前向方法，覆盖了 __call__ 特殊方法。

示例

>>> 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: str = None decoder_pretrained_model_name_or_path: 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[typing.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 执行。

请注意，这仅指定计算的 dtype，不会影响模型参数的 dtype。

如果您希望更改模型参数的 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 类方法创建解码器时，它将被实例化为具有库的基础视觉模型类之一的模块 (flax.nn.Module) 作为编码器模块和另一个作为解码器模块的 Transformer 架构。

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: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (形状为 (batch_size, num_channels, height, width) 的 jnp.ndarray) — 像素值。像素值可以使用视觉模型的图像处理器获得。例如，使用 AutoImageProcessor。有关详细信息，请参阅 ViTImageProcessor.call()。
decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 jnp.ndarray, 可选) — 词汇表中解码器输入序列标记的索引。

索引可以使用 PreTrainedTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是解码器输入 ID？
decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 jnp.ndarray, 可选) — 默认行为：生成一个张量，该张量忽略 decoder_input_ids 中的填充标记。默认情况下，也将使用因果掩码。
decoder_position_ids (形状为 (batch_size, sequence_length) 的 jnp.ndarray, 可选) — 位置嵌入中每个解码器输入序列标记的位置索引。在范围 [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 之前的每个词汇表标记的得分）。
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 (jnp.ndarray，形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出隐藏状态序列。
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 的前向方法，覆盖了 __call__ 特殊方法。

示例

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

< 源代码 >

( 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 上更新