VisualBERT

概述

VisualBERT 模型在 VisualBERT: A Simple and Performant Baseline for Vision and Language 中提出，作者是 Liunian Harold Li、Mark Yatskar、Da Yin、Cho-Jui Hsieh、Kai-Wei Chang。VisualBERT 是一个在各种（图像，文本）对上训练的神经网络。

该论文的摘要如下：

我们提出了 VisualBERT，这是一个简单而灵活的框架，用于建模广泛的视觉和语言任务。VisualBERT 由 Transformer 层堆栈组成，这些层使用自注意力机制隐式地对齐输入文本的元素和关联输入图像中的区域。我们进一步提出了两个视觉接地的语言模型目标，用于在图像字幕数据上预训练 VisualBERT。在四个视觉和语言任务（包括 VQA、VCR、NLVR2 和 Flickr30K）上的实验表明，VisualBERT 的性能优于或匹敌最先进的模型，同时显着更简单。进一步的分析表明，VisualBERT 可以将语言元素接地到图像区域，而无需任何显式监督，甚至对句法关系敏感，例如，跟踪动词与其论元对应的图像区域之间的关联。

此模型由 gchhablani 贡献。原始代码可以在这里找到。

使用技巧

提供的大多数检查点都适用于 VisualBertForPreTraining 配置。提供的其他检查点是下游任务的微调检查点 - VQA（‘visualbert-vqa’）、VCR（‘visualbert-vcr’）、NLVR2（‘visualbert-nlvr2’）。因此，如果您不处理这些下游任务，建议您使用预训练的检查点。
对于 VCR 任务，作者使用微调的检测器来生成所有检查点的视觉嵌入。我们不提供检测器及其权重作为软件包的一部分，但它将在研究项目中提供，并且状态可以直接加载到提供的检测器中。

VisualBERT 是一种多模态视觉和语言模型。它可用于视觉问题回答、多项选择、视觉推理和区域到短语的对应任务。VisualBERT 使用类似 BERT 的 Transformer 来准备图像-文本对的嵌入。文本和视觉特征都被投影到具有相同维度的潜在空间。

为了将图像馈送到模型，每张图像都通过预训练的对象检测器，并提取区域和边界框。作者使用通过预训练的 CNN（如 ResNet）传递这些区域后生成的特征作为视觉嵌入。他们还添加了绝对位置嵌入，并将生成的向量序列馈送到标准 BERT 模型。文本输入在嵌入层中连接在视觉嵌入的前面，并且预计像 BERT 中一样，由 [CLS] 和 [SEP] 标记分隔。分段 ID 也必须针对文本和视觉部分进行适当设置。

BertTokenizer 用于编码文本。必须使用自定义检测器/图像处理器来获取视觉嵌入。以下示例笔记本展示了如何将 VisualBERT 与类似 Detectron 的模型一起使用

VisualBERT VQA 演示笔记本：此笔记本包含 VisualBERT VQA 的示例。
为 VisualBERT 生成嵌入（Colab 笔记本）：此笔记本包含有关如何生成视觉嵌入的示例。

以下示例显示如何使用 VisualBertModel 获取最后一个隐藏状态

>>> import torch
>>> from transformers import BertTokenizer, VisualBertModel

>>> model = VisualBertModel.from_pretrained("uclanlp/visualbert-vqa-coco-pre")
>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")

>>> inputs = tokenizer("What is the man eating?", return_tensors="pt")
>>> # this is a custom function that returns the visual embeddings given the image path
>>> visual_embeds = get_visual_embeddings(image_path)

>>> visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
>>> visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)
>>> inputs.update(
...     {
...         "visual_embeds": visual_embeds,
...         "visual_token_type_ids": visual_token_type_ids,
...         "visual_attention_mask": visual_attention_mask,
...     }
... )
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

VisualBertConfig

class transformers.VisualBertConfig

< source >

( vocab_size = 30522 hidden_size = 768 visual_embedding_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 bypass_transformer = False special_visual_initialize = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

vocab_size (int, 可选, 默认为 30522) — VisualBERT 模型的词汇表大小。定义了在调用 VisualBertModel 时传递的 inputs_ids 可以表示的不同 token 的数量。模型的词汇表大小。定义了可以由传递给 VisualBertModel 的 forward 方法的 inputs_ids 表示的不同 token。
hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
visual_embedding_dim (int, 可选, 默认为 512) — 要传递给模型的视觉嵌入的维度。
num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。
num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（即，前馈）层的维度。
hidden_act (str 或 function, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
hidden_dropout_prob (float, optional, 默认为 0.1) — 用于嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。
max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512 或 1024 或 2048）。
type_vocab_size (int, optional, 默认为 2) — 当调用 VisualBertModel 时，传递的 token_type_ids 的词汇表大小。
initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
bypass_transformer (bool, optional, 默认为 False) — 模型是否应该绕过 transformer 来处理视觉嵌入。如果设置为 True，模型将直接连接来自 VisualBertEmbeddings 的视觉嵌入和来自 transformers 的文本输出，然后将其传递给自注意力层。
special_visual_initialize (bool, optional, 默认为 True) — 视觉 token 类型和位置类型嵌入权重是否应与文本 token 类型和位置类型嵌入以相同方式初始化。当设置为 True 时，文本 token 类型和位置类型嵌入的权重将复制到相应的视觉嵌入层。

这是用于存储 VisualBertModel 配置的配置类。它用于根据指定的参数实例化 VisualBERT 模型，定义模型架构。使用默认值实例化配置将产生与 VisualBERT uclanlp/visualbert-vqa-coco-pre 架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。

示例

>>> from transformers import VisualBertConfig, VisualBertModel

>>> # Initializing a VisualBERT visualbert-vqa-coco-pre style configuration
>>> configuration = VisualBertConfig.from_pretrained("uclanlp/visualbert-vqa-coco-pre")

>>> # Initializing a model (with random weights) from the visualbert-vqa-coco-pre style configuration
>>> model = VisualBertModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

VisualBertModel

class transformers.VisualBertModel

< source >

( config add_pooling_layer = True )

参数

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

裸 VisualBert 模型 transformer 输出原始隐藏状态，顶部没有任何特定的 head。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。

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

该模型可以充当编码器（仅使用自注意力），遵循 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 在 Attention is all you need 中描述的架构。

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None visual_embeds: typing.Optional[torch.FloatTensor] = None visual_attention_mask: typing.Optional[torch.LongTensor] = None visual_token_type_ids: typing.Optional[torch.LongTensor] = None image_text_alignment: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor) — 词汇表中输入序列 token 的索引。

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

什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, optional) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被 mask，
- 0 表示 token 已被 mask。
什么是 attention mask？
token_type_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, optional) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
什么是 token 类型 ID？
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, optional) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor, optional) — 用于 nullify 自注意力模块的选定 head 的 Mask。Mask 值在 [0, 1] 中选择：
- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, optional) — 或者，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
visual_embeds (形状为 (batch_size, visual_seq_length, visual_embedding_dim) 的 torch.FloatTensor, optional) — 视觉输入的嵌入表示，通常使用对象检测器导出。
visual_attention_mask (形状为 (batch_size, visual_seq_length) 的 torch.FloatTensor, optional) — 用于避免对视觉嵌入执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被 mask，
- 0 表示 token 已被 mask。
什么是 attention mask？
visual_token_type_ids (形状为 (batch_size, visual_seq_length) 的 torch.LongTensor, optional) — 分段 token 索引，用于指示视觉嵌入的不同部分。

什么是 token 类型 ID？ VisualBERT 的作者将所有 token 的 visual_token_type_ids 设置为 1。
image_text_alignment (形状为 (batch_size, visual_seq_length, alignment_number) 的 torch.LongTensor, optional) — 图像-文本对齐用于确定视觉嵌入的位置 ID。
output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通 tuple。

返回值

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

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

last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) — 模型最后一层的输出端的隐藏状态序列。
pooler_output (形状为 (batch_size, hidden_size) 的 torch.FloatTensor) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理之后。例如，对于 BERT 系列模型，这会返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重通过预训练期间的下一句预测（分类）目标进行训练。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层，则为嵌入输出；每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的权重，用于计算自注意力头中的加权平均值。

VisualBertModel 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward 传递的配方需要在该函数内定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

示例

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image.
from transformers import AutoTokenizer, VisualBertModel
import torch

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = VisualBertModel.from_pretrained("uclanlp/visualbert-vqa-coco-pre")

inputs = tokenizer("The capital of France is Paris.", return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

inputs.update(
    {
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)

outputs = model(**inputs)

last_hidden_states = outputs.last_hidden_state

VisualBertForPreTraining

class transformers.VisualBertForPreTraining

< source >

( config )

参数

config (VisualBertConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。

VisualBert 模型，顶部带有两个头，如同预训练期间所做的那样：一个 masked language modeling 头和一个 sentence-image prediction (classification) 头。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None visual_embeds: typing.Optional[torch.FloatTensor] = None visual_attention_mask: typing.Optional[torch.LongTensor] = None visual_token_type_ids: typing.Optional[torch.LongTensor] = None image_text_alignment: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None sentence_image_labels: typing.Optional[torch.LongTensor] = None ) → transformers.models.visual_bert.modeling_visual_bert.VisualBertForPreTrainingOutput 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor) — 词汇表中输入序列标记的索引。

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

什么是输入 IDs？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, 可选) — 掩码，用于避免在 padding 标记索引上执行注意力。掩码值在 [0, 1] 中选择：
- 1 表示标记未被掩码，
- 0 表示标记被掩码。
什么是注意力掩码？
token_type_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
什么是标记类型 IDs？
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 IDs？
head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor, 可选) — 掩码，用于使自注意力模块的选定头无效。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩码，
- 0 表示头被掩码。
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
visual_embeds (形状为 (batch_size, visual_seq_length, visual_embedding_dim) 的 torch.FloatTensor, 可选) — 视觉输入的嵌入表示，通常使用对象检测器导出。
visual_attention_mask (形状为 (batch_size, visual_seq_length) 的 torch.FloatTensor, 可选) — 掩码，用于避免对视觉嵌入执行注意力。掩码值在 [0, 1] 中选择：
- 1 表示标记未被掩码，
- 0 表示标记被掩码。
什么是注意力掩码？
visual_token_type_ids (形状为 (batch_size, visual_seq_length) 的 torch.LongTensor, 可选) — 分段标记索引，用于指示视觉嵌入的不同部分。

什么是标记类型 IDs？ VisualBERT 的作者将所有标记的 visual_token_type_ids 设置为 1。
image_text_alignment (形状为 (batch_size, visual_seq_length, alignment_number) 的 torch.LongTensor, 可选) — 图像-文本对齐用于确定视觉嵌入的位置 IDs。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
labels (形状为 (batch_size, total_sequence_length) 的 torch.LongTensor, 可选) — 用于计算 masked language modeling 损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算
sentence_image_labels (形状为 (batch_size,) 的 torch.LongTensor, 可选) — 用于计算句子-图像预测（分类）损失的标签。输入应为序列对（请参阅 input_ids 文档字符串）。索引应在 [0, 1] 中：
- 0 表示序列 B 是给定图像的序列 A 的匹配对，
- 1 表示序列 B 是给定图像的关于 A 的随机序列。

返回值

transformers.models.visual_bert.modeling_visual_bert.VisualBertForPreTrainingOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.visual_bert.modeling_visual_bert.VisualBertForPreTrainingOutput 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (VisualBertConfig) 和输入。

loss (可选, 当提供 labels 时返回, 形状为 (1,) 的 torch.FloatTensor) — 总损失，作为 masked language modeling 损失和句子-图像预测（分类）损失的总和。
prediction_logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇表标记的分数）。
seq_relationship_logits (形状为 (batch_size, 2) 的 torch.FloatTensor) — 句子-图像预测（分类）头的预测分数（SoftMax 之前 True/False 延续的分数）。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (嵌入输出一个；每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出的隐藏状态，加上初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的权重，用于计算自注意力头中的加权平均值。

VisualBertForPreTraining 的 forward 方法，覆盖了 __call__ 特殊方法。

示例

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForPreTraining

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = VisualBertForPreTraining.from_pretrained("uclanlp/visualbert-vqa-coco-pre")

inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

inputs.update(
    {
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)
max_length = inputs["input_ids"].shape[-1] + visual_embeds.shape[-2]
labels = tokenizer(
    "The capital of France is Paris.", return_tensors="pt", padding="max_length", max_length=max_length
)["input_ids"]
sentence_image_labels = torch.tensor(1).unsqueeze(0)  # Batch_size


outputs = model(**inputs, labels=labels, sentence_image_labels=sentence_image_labels)
loss = outputs.loss
prediction_logits = outputs.prediction_logits
seq_relationship_logits = outputs.seq_relationship_logits

VisualBertForQuestionAnswering

class transformers.VisualBertForQuestionAnswering

< source >

( config )

参数

config (VisualBertConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。

VisualBert 模型，顶部带有用于 VQA 的分类/回归头（池化输出顶部的 dropout 和线性层）。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None visual_embeds: typing.Optional[torch.FloatTensor] = None visual_attention_mask: typing.Optional[torch.LongTensor] = None visual_token_type_ids: typing.Optional[torch.LongTensor] = None image_text_alignment: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor) — 词汇表中输入序列 tokens 的索引。

索引可以通过 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 IDs？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask values selected in [0, 1]:
- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 已被掩盖。
什么是 attention masks？
token_type_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — Segment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:
- 0 对应 sentence A token，
- 1 对应 sentence B token。
什么是 token type IDs？
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是 position IDs？
head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor, 可选) — 掩码，用于 nullify 自注意力模块的选定头。 Mask values selected in [0, 1]:
- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
visual_embeds (形状为 (batch_size, visual_seq_length, visual_embedding_dim) 的 torch.FloatTensor, 可选) — 可视输入的嵌入表示，通常使用对象检测器导出。
visual_attention_mask (形状为 (batch_size, visual_seq_length) 的 torch.FloatTensor, 可选) — 掩码，用于避免在视觉嵌入上执行 attention。 Mask values selected in [0, 1]:
- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 已被掩盖。
什么是 attention masks？
visual_token_type_ids (形状为 (batch_size, visual_seq_length) 的 torch.LongTensor, 可选) — Segment token indices to indicate different portions of the visual embeds.

什么是 token type IDs？ VisualBERT 的作者将所有 tokens 的 visual_token_type_ids 设置为 1。
image_text_alignment (形状为 (batch_size, visual_seq_length, alignment_number) 的 torch.LongTensor, 可选) — 图像-文本对齐用于决定视觉嵌入的位置 IDs。
output_attentions (bool, 可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回 tensors 下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回 tensors 下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。
labels (形状为 (batch_size, total_sequence_length) 的 torch.LongTensor, 可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。在 labels 和返回的 logits 之间计算 KLDivLoss。

返回值

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 的 tuple (如果传递了 return_dict=False 或者当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (VisualBertConfig) 和输入。

loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（或回归，如果 config.num_labels==1）分数（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层，则为嵌入输出；每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的权重，用于计算自注意力头中的加权平均值。

VisualBertForQuestionAnswering 的 forward 方法，覆盖了 __call__ 特殊方法。

示例

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForQuestionAnswering
import torch

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = VisualBertForQuestionAnswering.from_pretrained("uclanlp/visualbert-vqa")

text = "Who is eating the apple?"
inputs = tokenizer(text, return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

inputs.update(
    {
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)

labels = torch.tensor([[0.0, 1.0]]).unsqueeze(0)  # Batch size 1, Num labels 2

outputs = model(**inputs, labels=labels)
loss = outputs.loss
scores = outputs.logits

VisualBertForMultipleChoice

class transformers.VisualBertForMultipleChoice

< source >

( config )

参数

config (VisualBertConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。

VisualBert 模型，顶部带有多项选择分类头（池化输出顶部的一个线性层和一个 softmax），例如用于 VCR 任务。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None visual_embeds: typing.Optional[torch.FloatTensor] = None visual_attention_mask: typing.Optional[torch.LongTensor] = None visual_token_type_ids: typing.Optional[torch.LongTensor] = None image_text_alignment: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.MultipleChoiceModelOutput 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, num_choices, sequence_length) 的 torch.LongTensor) — 词汇表中输入序列 tokens 的索引。

索引可以通过 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 IDs？
attention_mask (形状为 (batch_size, num_choices, sequence_length) 的 torch.FloatTensor, 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask values selected in [0, 1]:
- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 已被掩盖。
什么是 attention masks？
token_type_ids (形状为 (batch_size, num_choices, sequence_length) 的 torch.LongTensor, 可选) — Segment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:
- 0 对应 sentence A token，
- 1 对应 sentence B token。
什么是 token type IDs？
position_ids (形状为 (batch_size, num_choices, sequence_length) 的 torch.LongTensor, 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是 position IDs？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于置空自注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择:
- 1 表示头是未被掩蔽的，
- 0 表示头是被掩蔽的。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, num_choices, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
visual_embeds (torch.FloatTensor，形状为 (batch_size, visual_seq_length, visual_embedding_dim)，可选) — 视觉输入的嵌入表示，通常使用对象检测器导出。
visual_attention_mask (torch.FloatTensor，形状为 (batch_size, visual_seq_length)，可选) — 用于避免对视觉嵌入执行注意力的掩码。掩码值在 [0, 1] 中选择:
- 1 表示 token 是未被掩蔽的，
- 0 表示 token 是被掩蔽的。
什么是注意力掩码？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 分段 token 索引，用于指示视觉嵌入的不同部分。

什么是 token 类型 ID？ VisualBERT 的作者将 visual_token_type_ids 设置为所有 token 的 1。
image_text_alignment (torch.LongTensor，形状为 (batch_size, visual_seq_length, alignment_number)，可选) — 图像-文本对齐用于决定视觉嵌入的位置 ID。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices-1] 中，其中 num_choices 是输入张量第二维的大小。（请参见上面的 input_ids）

返回值

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

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

loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 分类损失。
logits (torch.FloatTensor，形状为 (batch_size, num_choices)) — num_choices 是输入张量的第二维。（请参见上面的 input_ids）。

分类得分（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层，则为嵌入输出；每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的权重，用于计算自注意力头中的加权平均值。

VisualBertForMultipleChoice 的 forward 方法，覆盖了 __call__ 特殊方法。

示例

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForMultipleChoice
import torch

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = VisualBertForMultipleChoice.from_pretrained("uclanlp/visualbert-vcr")

prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
choice0 = "It is eaten with a fork and a knife."
choice1 = "It is eaten while held in the hand."

visual_embeds = get_visual_embeddings(image)
# (batch_size, num_choices, visual_seq_length, visual_embedding_dim)
visual_embeds = visual_embeds.expand(1, 2, *visual_embeds.shape)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

encoding = tokenizer([[prompt, prompt], [choice0, choice1]], return_tensors="pt", padding=True)
# batch size is 1
inputs_dict = {k: v.unsqueeze(0) for k, v in encoding.items()}
inputs_dict.update(
    {
        "visual_embeds": visual_embeds,
        "visual_attention_mask": visual_attention_mask,
        "visual_token_type_ids": visual_token_type_ids,
        "labels": labels,
    }
)
outputs = model(**inputs_dict)

loss = outputs.loss
logits = outputs.logits

VisualBertForVisualReasoning

class transformers.VisualBertForVisualReasoning

< source >

( config )

参数

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

VisualBert 模型，顶部带有序列分类头（在池化输出之上有一个 dropout 层和一个线性层），用于视觉推理，例如用于 NLVR 任务。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None visual_embeds: typing.Optional[torch.FloatTensor] = None visual_attention_mask: typing.Optional[torch.LongTensor] = None visual_token_type_ids: typing.Optional[torch.LongTensor] = None image_text_alignment: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。

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

什么是输入 ID？
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对 padding token 索引执行注意力的掩码。掩码值在 [0, 1] 中选择:
- 1 表示 token 是未被掩蔽的，
- 0 表示 token 是被掩蔽的。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引在 [0, 1] 中选择:
- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
什么是 token 类型 ID？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于置空自注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择:
- 1 表示头是未被掩蔽的，
- 0 表示头是被掩蔽的。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
visual_embeds (torch.FloatTensor，形状为 (batch_size, visual_seq_length, visual_embedding_dim)，可选) — 视觉输入的嵌入表示，通常使用对象检测器导出。
visual_attention_mask (torch.FloatTensor，形状为 (batch_size, visual_seq_length)，可选) — 用于避免对视觉嵌入执行注意力的掩码。掩码值在 [0, 1] 中选择:
- 1 表示 token 是未被掩蔽的，
- 0 表示 token 是被掩蔽的。
什么是注意力掩码？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 分段 token 索引，用于指示视觉嵌入的不同部分。

什么是 token 类型 ID？ VisualBERT 的作者将 visual_token_type_ids 设置为所有 token 的 1。
image_text_alignment (torch.LongTensor，形状为 (batch_size, visual_seq_length, alignment_number)，可选) — 图像-文本对齐用于决定视觉嵌入的位置 ID。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。分类损失（交叉熵）是针对这些标签计算的。

返回值

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

loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（或回归，如果 config.num_labels==1）分数（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层，则为嵌入输出；每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的权重，用于计算自注意力头中的加权平均值。

VisualBertForVisualReasoning 的 forward 方法，覆盖了 __call__ 特殊方法。

示例

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForVisualReasoning
import torch

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = VisualBertForVisualReasoning.from_pretrained("uclanlp/visualbert-nlvr2")

text = "Who is eating the apple?"
inputs = tokenizer(text, return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

inputs.update(
    {
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)

labels = torch.tensor(1).unsqueeze(0)  # Batch size 1, Num choices 2

outputs = model(**inputs, labels=labels)
loss = outputs.loss
scores = outputs.logits

VisualBertForRegionToPhraseAlignment

class transformers.VisualBertForRegionToPhraseAlignment

< source >

( config )

参数

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

带有 Masked Language Modeling 头的 VisualBert 模型，以及顶部的注意力层，用于区域到短语对齐，例如用于 Flickr30 Entities 任务。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None visual_embeds: typing.Optional[torch.FloatTensor] = None visual_attention_mask: typing.Optional[torch.LongTensor] = None visual_token_type_ids: typing.Optional[torch.LongTensor] = None image_text_alignment: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None region_to_phrase_position: typing.Optional[torch.LongTensor] = None labels: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

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

什么是输入 IDs？
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：
- 1 表示 tokens 未被 mask，
- 0 表示 tokens 已被 mask。
什么是 attention masks？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — Segment token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
什么是 token type IDs？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是 position IDs？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify self-attention 模块的选定 head 的 Mask。Mask 值在 [0, 1] 中选择：
- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
visual_embeds (torch.FloatTensor，形状为 (batch_size, visual_seq_length, visual_embedding_dim)，可选) — 可视输入的嵌入表示，通常使用对象检测器导出。
visual_attention_mask (torch.FloatTensor，形状为 (batch_size, visual_seq_length)，可选) — 用于避免对视觉嵌入执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：
- 1 表示 tokens 未被 mask，
- 0 表示 tokens 已被 mask。
什么是 attention masks？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — Segment token 索引，用于指示视觉嵌入的不同部分。

什么是 token type IDs？ VisualBERT 的作者将所有 tokens 的 visual_token_type_ids 设置为 1。
image_text_alignment (torch.LongTensor，形状为 (batch_size, visual_seq_length, alignment_number)，可选) — 图像-文本对齐用于决定视觉嵌入的位置 IDs。
output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions 张量。有关更多详细信息，请参阅返回的张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回的张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
region_to_phrase_position (torch.LongTensor，形状为 (batch_size, total_sequence_length)，可选) — 描述与文本 tokens 对应的图像嵌入位置的位置。
labels (torch.LongTensor，形状为 (batch_size, total_sequence_length, visual_sequence_length)，可选) — 用于计算 masked language modeling 损失的标签。KLDivLoss 是针对这些标签以及来自 attention 层的输出计算的。

返回值

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

loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（或回归，如果 config.num_labels==1）分数（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层，则为嵌入输出；每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的权重，用于计算自注意力头中的加权平均值。

VisualBertForRegionToPhraseAlignment 的 forward 方法，覆盖了 __call__ 特殊方法。

示例

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForRegionToPhraseAlignment
import torch

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = VisualBertForRegionToPhraseAlignment.from_pretrained("uclanlp/visualbert-vqa-coco-pre")

text = "Who is eating the apple?"
inputs = tokenizer(text, return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)
region_to_phrase_position = torch.ones((1, inputs["input_ids"].shape[-1] + visual_embeds.shape[-2]))

inputs.update(
    {
        "region_to_phrase_position": region_to_phrase_position,
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)

labels = torch.ones(
    (1, inputs["input_ids"].shape[-1] + visual_embeds.shape[-2], visual_embeds.shape[-2])
)  # Batch size 1

outputs = model(**inputs, labels=labels)
loss = outputs.loss
scores = outputs.logits

< > 更新 on GitHub

Transformers

VisualBERT

概述

使用技巧

VisualBertConfig

class transformers.VisualBertConfig

VisualBertModel

class transformers.VisualBertModel

forward

VisualBertForPreTraining

class transformers.VisualBertForPreTraining

forward

VisualBertForQuestionAnswering

class transformers.VisualBertForQuestionAnswering

forward

VisualBertForMultipleChoice

class transformers.VisualBertForMultipleChoice

forward

VisualBertForVisualReasoning

class transformers.VisualBertForVisualReasoning

forward

VisualBertForRegionToPhraseAlignment

class transformers.VisualBertForRegionToPhraseAlignment

forward