VisualBERT

概述

VisualBERT 模型由 Liunian Harold Li、Mark Yatskar、Da Yin、Cho-Jui Hsieh 和 Kai-Wei Chang 在 VisualBERT: A Simple and Performant Baseline for Vision and Language 中提出。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 模型中。文本输入在嵌入层中连接到视觉嵌入的前面，并期望由 [CLS] 和 [SEP] 标记包围，就像在 BERT 中一样。段落 ID 也必须为文本和视觉部分适当地设置。

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

VisualBERT VQA 演示 Notebook：此 Notebook 包含一个 VisualBERT VQA 的示例。
生成 VisualBERT 嵌入 (Colab Notebook)：此 Notebook 包含一个如何生成视觉嵌入的示例。

以下示例展示了如何使用 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

< 源 >

( 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 前向方法的 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, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。
max_position_embeddings (int, 可选, 默认为 512) — 此模型可能使用的最大序列长度。通常设置为一个较大的值以备不时之需（例如，512、1024 或 2048）。
type_vocab_size (int, 可选, 默认为 2) — 调用 VisualBertModel 时传递的 token_type_ids 的词汇量大小。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
bypass_transformer (bool, 可选, 默认为 False) — 模型是否应绕过 Transformer 来处理视觉嵌入。如果设置为 True，模型将直接将 VisualBertEmbeddings 中的视觉嵌入与 Transformer 的文本输出连接起来，然后将其传递给一个自注意力层。
special_visual_initialize (bool, 可选, 默认为 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

< 源 >

( config add_pooling_layer = True )

参数

config (VisualBertModel) — 带有模型所有参数的模型配置类。使用配置文件初始化并不会加载模型相关权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
add_pooling_layer (bool, 可选, 默认为 True) — 是否添加池化层。

该模型可以作为编码器（仅包含自注意力机制）运行，其架构遵循 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 在 Attention is all you need 中描述的结构。

此模型继承自 PreTrainedModel。有关库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）的更多信息，请查看父类文档。

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

前向传播

< 源 >

( 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 (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。

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

什么是输入 ID？
attention_mask (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充 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.n_positions - 1]。

什么是位置 ID？
head_mask (torch.LongTensor, 形状为 (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 表示未被掩码的标记，
- 0 表示被掩码的标记。
什么是注意力掩码？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 用于指示视觉嵌入不同部分的段标记索引。

什么是标记类型 ID？ VisualBERT 的作者将 visual_token_type_ids 设置为所有标记的 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 而不是普通元组。

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False 时），包含根据配置 (VisualBertConfig) 和输入的不同元素。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 经过用于辅助预训练任务的层处理后，序列中第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这会返回分类标记在经过线性层和 tanh 激活函数处理后的结果。线性层权重在预训练期间根据下一句预测（分类）目标进行训练。
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 pass 的配方需要在该函数中定义，但之后应该调用 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 (VisualBertForPreTraining) — 模型的配置类，包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重，只加载配置。要加载模型权重，请查看 from_pretrained() 方法。

VisualBert 模型，顶部带有两个头，如预训练期间所做：一个 masked language modeling（掩码语言建模）头和一个 sentence-image prediction (classification)（句子-图像预测（分类））头。

此模型继承自 PreTrainedModel。有关库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）的更多信息，请查看父类文档。

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

前向传播

< 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 (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

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

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

什么是位置 ID？
head_mask (torch.LongTensor，形状为 (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 表示未被掩码的标记，
- 0 表示被掩码的标记。
什么是注意力掩码？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 用于指示视觉嵌入不同部分的段标记索引。

什么是标记类型 ID？ VisualBERT 的作者将 visual_token_type_ids 设置为所有标记的 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, total_sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 之间（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失只对标签在 [0, ..., config.vocab_size] 之间的标记计算。
sentence_image_labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算句子-图像预测（分类）损失的标签。输入应该是一个序列对（参见 input_ids 文档字符串）。索引应在 [0, 1] 之间：
- 0 表示序列 B 与给定图像的序列 A 是匹配对，
- 1 表示序列 B 是相对于给定图像的随机序列。

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 时返回，torch.FloatTensor，形状为 (1,)) — 总损失，是掩码语言建模损失和句子-图像预测（分类）损失的总和。
prediction_logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇 token 的分数）。
seq_relationship_logits (torch.FloatTensor，形状为 (batch_size, 2)) — 句子-图像预测（分类）头的预测分数（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 (VisualBertForQuestionAnswering) — 模型的配置类，包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重，只加载配置。要加载模型权重，请查看 from_pretrained() 方法。

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

此模型继承自 PreTrainedModel。有关库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）的更多信息，请查看父类文档。

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

前向传播

< 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)，可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

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

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

什么是位置 ID？
head_mask (torch.LongTensor，形状为 (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 表示未被掩码的标记，
- 0 表示被掩码的标记。
什么是注意力掩码？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 用于指示视觉嵌入不同部分的段标记索引。

什么是标记类型 ID？ VisualBERT 的作者将 visual_token_type_ids 设置为所有标记的 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, total_sequence_length)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 之间。标签和返回的 logits 之间计算 KLDivLoss。

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 的元组 (如果传入 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 的前向方法，它覆盖了 __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 (VisualBertForMultipleChoice) — 模型的配置类，包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

Visual Bert 模型，顶部带有多项选择分类头（池化输出顶部的线性层和 softmax），例如用于 RocStories/SWAG 任务。

此模型继承自 PreTrainedModel。有关库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）的更多信息，请查看父类文档。

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

前向传播

< 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 (torch.LongTensor，形状为 (batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。

索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。

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

什么是位置 ID？
head_mask (torch.LongTensor，形状为 (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 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
什么是注意力掩码？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 段标记索引，用于指示视觉嵌入的不同部分。

什么是标记类型 ID？ VisualBERT 的作者将visual_token_type_ids 设置为所有标记的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 (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失。
logits (形状为 (batch_size, num_choices) 的 torch.FloatTensor) — 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 的前向方法，它覆盖了 __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 (VisualBertForVisualReasoning) — 模型的配置类，包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

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

此模型继承自 PreTrainedModel。有关库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）的更多信息，请查看父类文档。

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

前向传播

< 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)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。

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

什么是位置 ID？
head_mask (torch.LongTensor，形状为 (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 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
什么是注意力掩码？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 段标记索引，用于指示视觉嵌入的不同部分。

什么是标记类型 ID？ VisualBERT 的作者将visual_token_type_ids 设置为所有标记的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 的前向方法，它覆盖了 __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 (VisualBertForRegionToPhraseAlignment) — 模型的配置类，包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。

VisualBert 模型，顶部带有掩码语言建模头和注意力层，用于区域到短语对齐，例如 Flickr30 Entities 任务。

此模型继承自 PreTrainedModel。有关库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）的更多信息，请查看父类文档。

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

前向传播

< 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 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。

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

什么是位置 ID？
head_mask (torch.LongTensor，形状为 (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 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
什么是注意力掩码？
visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 段标记索引，用于指示视觉嵌入的不同部分。

什么是标记类型 ID？ VisualBERT 的作者将visual_token_type_ids 设置为所有标记的1。
image_text_alignment (torch.LongTensor，形状为 (batch_size, visual_seq_length, alignment_number)，可选) — 图像-文本对齐用于决定视觉嵌入的位置 ID。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多详情请参见返回张量中的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量中的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
region_to_phrase_position (torch.LongTensor 形状为 (batch_size, total_sequence_length), 可选) — 描述图像嵌入与文本标记对应位置的位置信息。
labels (torch.LongTensor 形状为 (batch_size, total_sequence_length, visual_sequence_length), 可选) — 用于计算掩码语言建模损失的标签。KLDivLoss 是针对这些标签和注意力层的输出计算的。

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

< > 在 GitHub 上更新

Transformers

VisualBERT

概述

使用提示

VisualBertConfig

class transformers.VisualBertConfig

VisualBertModel

class transformers.VisualBertModel

前向传播

VisualBertForPreTraining

class transformers.VisualBertForPreTraining

前向传播

VisualBertForQuestionAnswering

class transformers.VisualBertForQuestionAnswering

前向传播

VisualBertForMultipleChoice

class transformers.VisualBertForMultipleChoice

前向传播

VisualBertForVisualReasoning

class transformers.VisualBertForVisualReasoning

前向传播

VisualBertForRegionToPhraseAlignment

class transformers.VisualBertForRegionToPhraseAlignment

前向传播