视觉编码器解码器模型
概述
可以使用 VisionEncoderDecoderModel 使用任何基于 Transformer 的预训练视觉模型作为编码器（例如 ViT、BEiT、DeiT、Swin）和任何预训练语言模型作为解码器（例如 RoBERTa、GPT2、BERT、DistilBERT）来初始化图像到文本模型。
在 (例如) TrOCR: 基于 Transformer 的光学字符识别与预训练模型 中，李明浩、吕腾超、崔磊、陆怡娟、Dinei Florencio、张超、李周军、魏福如等人已经证明了使用预训练检查点初始化图像到文本序列模型的有效性。
经过训练/微调后，此类 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 需要在后续任务上对模型进行微调，如 编码器-解码器预热启动博文 中所示。为此，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
类 transformers.VisionEncoderDecoderConfig
< 源代码 >( **kwargs )
参数
- kwargs (可选) — 关键字参数字典。值得注意的是：
- encoder (PretrainedConfig, 可选) — 定义编码器配置的配置对象实例。
- decoder (PretrainedConfig, 可选) — 定义解码器配置的配置对象实例。
VisionEncoderDecoderConfig 是用于存储视觉编码器-解码器模型配置的配置类。它用于根据指定的参数实例化一个视觉编码器-文本解码器模型，定义编码器和解码器的配置。
配置对象继承自 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（或派生类）。
VisionEncoderDecoderModel
类 transformers.VisionEncoderDecoderModel
< 源代码 >( config: Optional = None encoder: Optional = None decoder: Optional = 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) 会带来显著的性能提升。
在训练/微调此类视觉编码器-文本解码器模型后，可以像其他任何模型一样保存/加载它（有关更多信息，请参阅示例）。
此模型继承自 PreTrainedModel。检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪注意力头等）。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
VisionEncoderDecoderModel 是一个通用的模型类，在使用 :meth~transformers.AutoModel.from_pretrained 类方法创建编码器并使用 :meth~transformers.AutoModelForCausalLM.from_pretrained 类方法创建解码器时，将被实例化为一个具有库中一个基本视觉模型类作为编码器和另一个作为解码器的 Transformer 架构。
forward
< 源代码 >( pixel_values: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以通过图像处理器获取（例如，如果您使用 ViT 作为编码器，则应使用 AutoImageProcessor）。有关详细信息，请参阅 ViTImageProcessor.call()。 - decoder_input_ids (
torch.LongTensor形状为(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个decoder_input_ids（参见past_key_values）。对于训练，模型会通过将
labels向右移动、将 -100 替换为pad_token_id并在其前面加上decoder_start_token_id来自动创建decoder_input_ids。 - decoder_attention_mask (
torch.BoolTensor形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。 - encoder_outputs (
tuple(torch.FloatTensor)，可选) — 此元组必须由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成last_hidden_state(torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)) 是编码器最后一层输出处的隐藏状态张量。用于解码器的交叉注意力。 - past_key_values (
tuple(tuple(torch.FloatTensor))长度为config.n_layers，每个元组包含 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用
past_key_values，则用户可以选择仅输入最后一个decoder_input_ids（形状为(batch_size, 1)），而不是所有decoder_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的标记将被忽略（掩码），损失仅针对[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输入到编码器前向函数中。 - 带有 decoder_ 前缀，将作为
**decoder_kwargs输入到解码器前向函数中。
- 没有前缀，将作为
返回
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 (
torch.FloatTensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的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 (
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: 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 模型要慢。
- 字符串，huggingface.co 上模型仓库中托管的预训练模型的模型 ID。例如
- 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")TFVisionEncoderDecoderModel
类 transformers.TFVisionEncoderDecoderModel
< 源代码 >( 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) 会带来显著的性能提升。
在训练/微调此类视觉编码器-文本解码器模型后，可以像其他任何模型一样保存/加载它（有关更多信息，请参阅示例）。
此模型继承自 TFPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、剪枝 head 等）。
此模型也是 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: 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 (形状为
(batch_size, target_sequence_length)的np.ndarray或tf.Tensor，可选) — 词汇表中解码器输入序列标记的索引。可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个decoder_input_ids（那些没有向此模型提供其过去键值状态的decoder_input_ids）（请参阅past_key_values）。提供用于序列到序列训练到解码器。可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- decoder_attention_mask (形状为
(batch_size, target_sequence_length)的np.ndarray或tf.Tensor，可选) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。 - encoder_outputs (
tuple(tuple(tf.Tensor)，可选) — 此元组必须由 (last_hidden_state、可选：hidden_states、可选：attentions) 组成。last_hidden_state(形状为(batch_size, sequence_length, hidden_size)的tf.Tensor) 是编码器最后一层输出处的隐藏状态张量。用于解码器的交叉注意力。 - past_key_values (长度为
config.n_layers的tuple(tuple(tf.Tensor))，每个元组包含 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用
past_key_values，则用户可以选择仅输入最后一个decoder_input_ids（那些没有向此模型提供其过去键值状态的decoder_input_ids），形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递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 (
tf.Tensor形状为(n,)，可选，其中 n 是非掩码标签的数量，在提供labels时返回) — 语言建模损失。 -
logits (
tf.Tensor形状为(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 (
tf.Tensor形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出处的隐藏状态序列。 -
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__ 特殊方法。
虽然前向传递的配方需要在此函数内定义，但之后应调用 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
< 源代码 >( 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。
- 一个字符串，表示托管在 huggingface.co 模型仓库中的预训练模型的模型 ID。例如
- 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")FlaxVisionEncoderDecoderModel
类 transformers.FlaxVisionEncoderDecoderModel
< 源代码 >( config: VisionEncoderDecoderConfig input_shape: Optional = 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。
此类可用于使用任何预训练的视觉自动编码模型作为编码器，以及任何预训练的文本自回归模型作为解码器来初始化图像到文本序列模型。编码器通过 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) 会带来显著的性能提升。
在训练/微调此类视觉编码器-文本解码器模型后，可以像其他任何模型一样保存/加载它（有关更多信息，请参阅示例）。
此模型继承自 FlaxPreTrainedModel。请查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪注意力头等）。
此模型也是 Flax Linen 的 flax.nn.Module 子类。将其用作常规 Flax 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。
FlaxVisionEncoderDecoderModel 是一个通用的模型类，在使用 :meth~transformers.FlaxAutoModel.from_pretrained 类方法创建编码器和 :meth~transformers.FlaxAutoModelForCausalLM.from_pretrained 类方法创建解码器时，将被实例化为一个 transformer 架构，其模块（flax.nn.Module）分别为库中的一个基础视觉模型类。
__call__
< 源代码 >( pixel_values: 数组 decoder_input_ids: 可选 decoder_attention_mask: 可选 decoder_position_ids: 可选 output_attentions: 可选 output_hidden_states: 可选 return_dict: 可选 train: 布尔值 params: 字典 dropout_rng: PRNGKey ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 元组(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()。
- 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 (
布尔值, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
布尔值, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
布尔值, 可选) — 如果设置为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 (
jnp.ndarray形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的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__ 特殊方法。
虽然前向传递的配方需要在此函数内定义，但之后应调用 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
< 源代码 >( encoder_pretrained_model_name_or_path: Union = None decoder_pretrained_model_name_or_path: Union = 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/。
- 一个字符串，huggingface.co 上模型仓库中托管的预训练模型的模型 ID。例如
- 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")