Transformers 4.37 中文文档（九十六）（2）

Transformers 4.37 中文文档（九十六）（1）https://developer.aliyun.com/article/1564049

VisionEncoderDecoderModel

class transformers.VisionEncoderDecoderModel

<来源>

( config: Optional = None encoder: Optional = None decoder: Optional = None )

参数

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

这个类可以用来初始化一个图像到文本序列模型，其中预训练的视觉自编码模型作为编码器，预训练的文本自回归模型作为解码器。编码器通过  from_pretrained() 函数加载，解码器通过 from_pretrained()  函数加载。交叉注意力层会自动添加到解码器，并应在下游生成任务（如图像字幕）上进行微调。

在 Leveraging Pre-trained Checkpoints for Sequence Generation Tasks 中，Sascha Rothe、Shashi Narayan、Aliaksei Severyn、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 展示了使用预训练检查点初始化序列到序列模型进行序列生成任务的有效性。

此外，在 TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models 中，展示了如何利用大型预训练视觉模型进行光学字符识别（OCR）可以显著提高性能。

训练/微调了这样一个视觉-编码器-文本-解码器模型后，它可以像其他模型一样保存/加载（有关更多信息，请参阅示例）。

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

这个模型也是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

VisionEncoderDecoderModel 是一个通用的模型类，当使用  :meth*~transformers.AutoModel.from_pretrained*  类方法为编码器创建一个基础视觉模型类，并为解码器创建另一个基础视觉模型类时，将实例化为一个变压器架构。

forward

< source >

( 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以通过图像处理器获得（例如，如果您使用 ViT 作为编码器，应该使用 AutoImageProcessor）。有关详细信息，请参阅 ViTImageProcessor.call()。
  
• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。
  可以使用 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 (torch.BoolTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。
  
• encoder_outputs (tuple(torch.FloatTensor), optional) — 此元组必须包含 (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state (torch.FloatTensor of shape (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，用户可以选择仅输入形状为 (batch_size, 1) 的最后的 decoder_input_ids（即没有将过去的键值状态提供给该模型的那些）而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids。
  
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 decoder_input_ids。如果您想要更多控制如何将 decoder_input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
  
• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算解码器的掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 范围内的标记。
  
• use_cache (bool, optional) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的 attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的 hidden_states。
  
• return_dict (bool, optional) — 如果设置为 True，模型将返回一个 ~utils.Seq2SeqLMOutput 而不是一个普通元组。
  
• kwargs (optional) — 剩余的关键字参数字典。关键字参数有两种类型：

• 没有前缀，将作为 **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,)，optional，当提供labels时返回) — 语言建模损失。
  
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values (tuple(tuple(torch.FloatTensor))，optional，当传递use_cache=True或config.use_cache=True时返回) — 一个长度为config.n_layers的元组，每个元组有 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)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个元组，包含形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor（如果模型有嵌入层，则为嵌入层输出的一个+每层输出的一个）。
  解码器在每一层输出的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 一个元组，包含形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor（每层一个）。
  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — 一个元组，包含形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor（每层一个）。
  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个元组，包含形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor（如果模型有嵌入层，则为嵌入层输出的一个+每层输出的一个）。
  编码器在每一层输出的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — 一个元组，包含形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor（每层一个）。
  编码器的注意力权重，在注意力 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.cls_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，可选）- 启动图像编码器所需的信息。可以是：

• 一个字符串，预训练模型的模型 ID，托管在 huggingface.co 上的模型存储库内。一个示例是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）- 启动文本解码器所需的信息。可以是：

• 一个字符串，预训练模型的模型 ID，托管在 huggingface.co 上的模型存储库内。有效的模型 ID 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间，如dbmdz/bert-base-german-cased。
  
• 一个包含使用 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", "bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-bert")
>>> # load fine-tuned model
>>> model = VisionEncoderDecoderModel.from_pretrained("./vit-bert")

TensorFlowHide TensorFlow 内容

TFVisionEncoderDecoderModel

class 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 的《利用预训练检查点进行序列生成任务》中展示了使用预训练检查点初始化序列生成任务的序列到序列模型的有效性。

此外，在TrOCR: 基于 Transformer 的预训练模型的光学字符识别中展示了如何利用大型预训练的视觉模型进行光学字符识别（OCR）可以显著提高性能。

在训练/微调了这样一个 Vision-Encoder-Text-Decoder 模型之后，它可以像任何其他模型一样保存/加载（查看示例以获取更多信息）。

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

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

TFVisionEncoderDecoderModel 是一个通用模型类，当使用 from_pretrained()类方法为编码器创建一个库中的基础视觉模型类，并为解码器创建另一个基础模型类时，将实例化为一个变压器架构。

call

<来源>

( 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or 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 or tf.Tensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。
  可以使用 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 or tf.Tensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。
  
• encoder_outputs (tuple(tuple(tf.Tensor), optional) — 这个元组必须包含 (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) 是编码器最后一层的隐藏状态张量。用于解码器的交叉注意力。
  
• past_key_values (tuple(tuple(tf.Tensor)) of length config.n_layers with each tuple having 4 tensors of shape (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 or tf.Tensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递 decoder_input_ids。如果您想要更多控制权来将 decoder_input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
  
• labels (np.ndarray or tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算解码器的掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size]（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。
  
• use_cache (bool, optional) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  
• return_dict (bool, optional) — 如果设置为 True，模型将返回一个 ~utils.Seq2SeqLMOutput 而不是一个普通元组。
  
• training (bool, optional, 默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
  
• kwargs (optional) — 剩余的关键字参数字典。关键字参数有两种类型：

• 没有前缀，将作为编码器前向函数的**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 of shape (n,), optional, 其中 n 是未屏蔽标签的数量，在提供labels时返回) — 语言建模损失。
  
• logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values (List[tf.Tensor], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。
  包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。
  
• decoder_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组。
  解码器在每一层输出的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。
  解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。
  解码器的交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，一个用于每一层的输出）。
  编码器在每一层输出的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。
  编码器的注意力权重，在注意力 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("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", "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，可选） — 初始化编码器所需的信息。可以是：

• 预训练模型的模型 id，托管在 huggingface.co 上的模型存储库中。例如，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） — 初始化解码器所需的信息。可以是：

• 预训练模型的模型 id，托管在 huggingface.co 上的模型存储库中。有效的模型 id 可以位于根级别，如bert-base-uncased，或在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。
  
• 指向包含使用 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", "bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-bert")
>>> # load fine-tuned model
>>> model = TFVisionEncoderDecoderModel.from_pretrained("./vit-bert")

JAXHide JAX content

FlaxVisionEncoderDecoderModel

class 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，不影响模型参数的 dtype。
  如果您希望更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。
  

这个类可以用来初始化一个图像到文本序列模型，其中编码器是任何预训练的视觉自编码模型，解码器是任何预训练的文本自回归模型。编码器通过  from_pretrained()函数加载，解码器通过  from_pretrained()函数加载。交叉注意力层会自动添加到解码器上，并应该在下游生成任务（如图像字幕）上进行微调。

在Sascha Rothe, Shashi Narayan, Aliaksei Severyn. Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu的研究中展示了使用预训练检查点初始化序列生成任务的序列到序列模型的有效性。

此外，在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类方法为编码器创建模块（flax.nn.Module）时，会实例化为一个 transformer 架构，库中的一个基本视觉模型类作为编码器模块，另一个作为解码器模块，并使用:meth~transformers.FlaxAutoModelForCausalLM.from_pretrained*类方法为解码器创建模块。

__call__

< source >

( pixel_values: Array decoder_input_ids: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or 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 (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时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。
  解码器在每一层输出的隐藏状态以及初始嵌入输出。
  
• decoder_attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  解码器交叉注意力层的注意力权重，在注意力 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。
  编码器在每层输出的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  编码器的注意力权重，在注意力 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("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", "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/。
  

• decoder_pretrained_model_name_or_path (Union[str, os.PathLike], 可选, 默认为None) — 初始化解码器所需的信息。可以是：

• 一个字符串，预训练模型的模型 ID，托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。
  
• 一个包含使用 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", "gpt2"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-gpt2")
>>> # load fine-tuned model
>>> model = FlaxVisionEncoderDecoderModel.from_pretrained("./vit-gpt2")

Transformers 4.37 中文文档（九十六）（3）https://developer.aliyun.com/article/1564051