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 对文本进行编码。必须使用自定义检测器/图像处理器来获取视觉嵌入。以下示例笔记本展示了如何使用类似Detectron的模式使用VisualBERT
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_stateVisualBertConfig
类 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可以表示的不同标记的数量。模型词汇表大小。定义了在将inputs_ids传入 VisualBertModel 的前向方法时可以表示的不同标记。 - 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) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。 - layer_norm_eps (
float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。 - bypass_transformer (
bool, 可选, 默认为False) — 是否跳过 transformer 用于视觉嵌入。如果设置为True，则模型直接将来自VisualBertEmbeddings的视觉嵌入与来自 transformers 的文本输出连接，然后传递到自注意力层。 - special_visual_initialize (
bool, 可选, 默认为True) — 视觉标记类型和位置类型嵌入权重是否应该初始化与文本标记类型和位置类型嵌入权重相同。如果设置为True，则将文本标记类型和位置类型嵌入的权重复制到相应的视觉嵌入层。
这是用于存储 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.configVisualBertModel
类 transformers.VisualBertModel
< source >( config add_pooling_layer = True )
参数
- config (VisualBertConfig) — 包含所有模型参数的模型配置类。用配置文件初始化不会加载与模型关联的权重，只加载配置。请参阅 from_pretrained() 方法来加载模型权重。
这是裸VisualBert模型，输出不带任何特定头的原始隐藏状态。此模型继承自 PreTrainedModel。请参阅超类文档，了解库为其所有模型实现的一般方法（例如下载或保存，调整输入嵌入尺寸，剪枝头部等）。
此模型也是一种 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。
正向
< source >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None visual_embeds: Optional = None visual_attention_mask: Optional = None visual_token_type_ids: Optional = None image_text_alignment: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列token在词汇表中的索引。可以通过使用 AutoTokenizer 来获取索引。详细信息请参考 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor形状为(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。
- position_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 输入序列中每个标记的位置索引。位置在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
torch.FloatTensorof shape(num_heads,)or(num_layers, num_heads), optional) — 要取消选择的自注意力模块选定的头部的屏蔽。屏蔽值在[0, 1]范围内选择:- 1 表示头部没有被 屏蔽，
- 0 表示头部被 屏蔽。
- inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递一个嵌入表示，而不是传递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 （形状为
(batch_size, visual_seq_length, alignment_number)的torch.LongTensor，可选） — 用于决定视觉嵌入的位置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（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_hidden_states=True或当config.output_hidden_states=True` 时返回）——torch.FloatTensor元组（如果一个模型具有嵌入层，则为嵌入层的输出，每个层的输出分隔开来）的形状为(batch_size, sequence_length, hidden_size)。模型在每个层的输出以及可选的初始嵌入输出。
-
attentions（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_attentions=True或当config.output_attentions=True` 时返回）——torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。注意软化后的注意力权重，用于在自注意力的头部中进行加权平均。
《VisualBertModel》的前向方法，覆盖了__call__特殊方法。
尽管前向传递的食谱需要在函数内部定义，但应该调用`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_stateVisualBertForPreTraining
类 transformers.VisualBertForPreTraining
参数
此模型也是一种 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解所有与通用使用和行为相关的内容。
正向
( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None visual_embeds: 可选 = None visual_attention_mask: 可选 = None visual_token_type_ids: 可选 = None image_text_alignment: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None labels: 可选 = None sentence_image_labels: 可选 = 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()。
- attention_mask (
torch.FloatTensorof shape(batch_size, sequence_length), 可选) — 避免在填充词索引上执行注意力的掩码。掩码值选取范围在[0, 1]： - token_type_ids (
torch.LongTensorof shape(batch_size, sequence_length), 可选) — 段令牌索引，用于指示输入的前后部分。索引选取范围为[0, 1]： - position_ids (
torch.LongTensorof shape(batch_size, sequence_length), 可选) — 每个输入序列令牌在位置嵌入中的位置索引。选取范围在[0, config.max_position_embeddings - 1]。 - head_mask （shape 为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选） — 要注销自注意力模块中选定的头部，请使用此掩码。掩码值在[0, 1]范围内：- 1 表示该头部没有被 掩码，
- 0 表示该头部被 掩码。
- inputs_embeds （shape 为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） — 可选择直接传递嵌入表示，而不是传递input_ids。如果你希望对将input_ids索引转换为相关向量有更多控制，这非常有用，模型的内部嵌入查找矩阵无法满足。 - visual_embeds （shape 为
(batch_size, visual_seq_length, visual_embedding_dim)的torch.FloatTensor，可选） — 视觉输入的嵌入表示，通常通过对象检测器得到。 - 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.LongTensorof shape(batch_size, total_sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。设置为-100的令牌将被忽略（掩码），损失仅对[0, ..., config.vocab_size]范围内的标签进行计算 - sentence_image_labels (
torch.LongTensorof shape(batch_size,), optional) — 用于计算句子-图像预测（分类）损失的标签。输入应为序列对（参见input_ids文档字符串）。索引应在[0, 1]中：- 0 表示给定图像中序列 B 是与序列 A 匹配的对，
- 1 表示对于给定的图像，序列 B 是相对于 A 的随机序列。
返回值
transformers.models.visual_bert.modeling_visual_bert.VisualBertForPreTrainingOutput 或 tuple(torch.FloatTensor)
A transformers.models.visual_bert.modeling_visual_bert.VisualBertForPreTrainingOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False）根据配置（VisualBertConfig）和输入包含各种元素。
-
loss （optional，在提供
labels时返回，形状为(1,)的torch.FloatTensor） — 掩码语言建模损失和句子-图像预测（分类）损失的总和。 -
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)，optional，在传递output_hidden_states=True时返回或当config.output_hidden_states=True时返回） — 一个torch.FloatTensor的元组（每个层的输出中的一个加上嵌入输出）的形状为(batch_size, sequence_length, hidden_size)。每个层的输出和初始嵌入输出的隐藏状态。
-
attentions（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_attentions=True或当config.output_attentions=True` 时返回）——torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。注意软化后的注意力权重，用于在自注意力的头部中进行加权平均。
VisualBertForPreTraining 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传递的食谱需要在函数内部定义，但应该调用`Module`实例而不是此函数，因为前者处理了前向和后向处理步骤，而后者则默默忽略它们。
示例
# 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_logitsVisualBertForQuestionAnswering
类 transformers.VisualBertForQuestionAnswering
< 来源 >参数
- 配置 (VisualBertConfig) - 包含模型所有参数的模型配置类。使用配置文件初始化不加载模型相关的权重，只加载配置。请查看 from_pretrained() 方法以加载模型权重。
VisualBert 模型，顶部带有一个用于 VQA 的分类/回归头（在池化输出上方有一个 dropout 层和线性层）。
此模型也是一种 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解所有与通用使用和行为相关的内容。
正向
< 来源 >( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None visual_embeds: 可选 = None visual_attention_mask: 可选 = None visual_token_type_ids: 可选 = None image_text_alignment: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None labels: 可选 = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids （形状为
(batch_size, sequence_length)的torch.LongTensor） — 输入序列词的词汇索引。可以使用AutoTokenizer获得索引。详细信息请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- attention_mask （形状为
(batch_size, sequence_length)的torch.FloatTensor，可选） — 避免对填充令牌索引执行注意力操作的掩码。选定的掩码值在[0, 1]:- 1 代表未掩码的令牌，
- 0 代表掩码的令牌。
- token_type_ids （形状为
(batch_size, sequence_length)的torch.LongTensor，可选） — 段令牌索引，以指明输入的第一和第二部分。索引选在[0, 1]:- 0 对应于 A 句的令牌，
- 1 对应于 B 句的令牌。
- position_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 每个输入序列标记的位置在位置嵌入中的索引。从[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
torch.FloatTensorof shape(num_heads,)or(num_layers, num_heads), optional) — 用于屏蔽自注意力模块中选择的头部的掩码。掩码值在[0, 1]内选择：- 1表示头部未屏蔽，
- 0表示头部已屏蔽。
- inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可以选择直接传递嵌入表示而不是传递input_ids。如果想要比模型内部嵌入查找矩阵有更多的控制权，将其转换为相关向量，这很有用。 - visual_embeds (
torch.FloatTensorof shape(batch_size, visual_seq_length, visual_embedding_dim), optional) — 视觉输入的嵌入表示，通常使用对象检测器生成。 - visual_attention_mask (
torch.FloatTensorof shape(batch_size, visual_seq_length), optional) — 避免在对视觉嵌入执行注意力的掩码。掩码值选择在[0, 1]：- 1 为 未掩码 的标记；
- 0 为 掩码 的标记。
- visual_token_type_ids (
torch.LongTensorof shape(batch_size, visual_seq_length), optional) — 标记类别指数以指示视觉嵌入的不同部分。什么是标记类别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, optional) — 是否返回一个ModelOutput，而不是一个普通元组。 - labels (
torch.LongTensorof shape(batch_size, total_sequence_length), optional) — 用来计算序列分类/回归损失的标签。索引应该在[0, ..., config.num_labels - 1]之间。标签和返回的logits之间计算一个KLDivLoss。
返回值
transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)
transformers.modeling_outputs.SequenceClassifierOutput 或一系列 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含根据配置（VisualBertConfig）和输入的不同元素。
-
loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 分类（或回归，如果 config.num_labels==1）损失。 -
logits (
torch.FloatTensorof shape(batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（均在SoftMax之前）。 -
hidden_states（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_hidden_states=True或当config.output_hidden_states=True` 时返回）——torch.FloatTensor元组（如果一个模型具有嵌入层，则为嵌入层的输出，每个层的输出分隔开来）的形状为(batch_size, sequence_length, hidden_size)。模型在每个层的输出以及可选的初始嵌入输出。
-
attentions（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_attentions=True或当config.output_attentions=True` 时返回）——torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。注意软化后的注意力权重，用于在自注意力的头部中进行加权平均。
VisualBertForQuestionAnswering 前向方法重写了 __call__ 特殊方法。
尽管前向传递的食谱需要在函数内部定义，但应该调用`Module`实例而不是此函数，因为前者处理了前向和后向处理步骤，而后者则默默忽略它们。
示例
# 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.logitsVisualBertForMultipleChoice
类 transformers.VisualBertForMultipleChoice
< source >参数
- 配置 (VisualBertConfig) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只有配置。查看 from_pretrained() 方法以加载模型权重。
在顶部带有多个选择分类头（在池化输出上方的线性层和softmax）的VisualBert模型，例如VCR任务。
此模型也是一种 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解所有与通用使用和行为相关的内容。
正向
< 来源 >( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None visual_embeds: 可选 = None visual_attention_mask: 可选 = None visual_token_type_ids: 可选 = None image_text_alignment: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None labels: 可选 = None ) → transformers.modeling_outputs.MultipleChoiceModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。 使用 AutoTokenizer 可以获取索引。详细信息请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 - attention_mask (
torch.FloatTensor形状为(batch_size, num_choices, sequence_length)，可选) — 用于防止对填充标记索引执行注意力的掩码。掩码值在[0, 1]之间选择：- 1 对应 非掩码 的标记；
- 0 对应 掩码 的标记。
- token_type_ids (
torch.LongTensor形状为(batch_size, num_choices, sequence_length)，可选) — 表明输入输入的第一部和第二部分的标记段索引。索引在[0, 1]之间选择：- 0 对应于 句子 A 标记；
- 1 对应于 句子 B 标记。
- position_ids （shape 形状的 torch.LongTensor，形状为
(batch_size, num_choices, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]之间。 - head_mask （shape 形状的 torch.FloatTensor，形状为
(num_heads,)或(num_layers, num_heads)，可选）— 用于取消选择自注意力模块中选择的头部的掩码。掩码值在[0, 1]之间：- 1 表示头部 未掩码，
- 0 表示头部 已掩码。
- inputs_embeds （shape 形状的 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]： - visual_token_type_ids （类型为
torch.LongTensor，形状为(batch_size, visual_seq_length)，可选） —— 标记段索引以指示视觉嵌入的不同部分。 - 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)
A 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（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_hidden_states=True或当config.output_hidden_states=True` 时返回）——torch.FloatTensor元组（如果一个模型具有嵌入层，则为嵌入层的输出，每个层的输出分隔开来）的形状为(batch_size, sequence_length, hidden_size)。模型在每个层的输出以及可选的初始嵌入输出。
-
attentions（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_attentions=True或当config.output_attentions=True` 时返回）——torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。注意软化后的注意力权重，用于在自注意力的头部中进行加权平均。
VisualBertForMultipleChoice 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传递的食谱需要在函数内部定义，但应该调用`Module`实例而不是此函数，因为前者处理了前向和后向处理步骤，而后者则默默忽略它们。
示例
# 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.logitsVisualBertForVisualReasoning
类 transformers.VisualBertForVisualReasoning
< source >参数
- config (VisualBertConfig) — 模型配置类，包含所有模型参数。使用配置文件初始化时，不会加载与模型关联的权重，只加载配置。请查看 from_pretrained() 方法以加载模型权重。
VisualBert 模型在顶部带有序列分类头（在池化输出上方的 dropout 层和线性层），用于视觉推理，例如用于 NLVR 任务。
此模型也是一种 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解所有与通用使用和行为相关的内容。
正向
< source >( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None visual_embeds: 可选 = None visual_attention_mask: 可选 = None visual_token_type_ids: 可选 = None image_text_alignment: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None labels: 可选 = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids （
torch.LongTensor形状为(batch_size, sequence_length)） — 词汇表中的输入序列标记的索引。索引可以通过使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask （
torch.FloatTensor形状为(batch_size, sequence_length)，可选） — 用于防止对填充标记索引执行注意力的掩码。掩码值选择在[0, 1]范围内：- 1 对应于 非掩码 标记，
- 0 对应于 掩码 标记。
- token_type_ids （
torch.LongTensor形状为(batch_size, sequence_length)，可选） — 段落标记索引以指示输入的第一部分和第二部分。索引选择在[0, 1]范围内：- 0 对应于 句子A 标记，
- 1 对应于 句子B 标记。
- position_ids （
torch.LongTensor，形状为(batch_size, sequence_length)，可选）——各个输入序列令牌在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 -
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）——取消选择self-attention模块选定的头的掩码。掩码值选择在[0, 1]：- 1表示头部未被掩码，
- 0表示头部被掩码。
- inputs_embeds （
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）——你可以选择直接传递嵌入表示，而不是传递input_ids。这对于你想比模型内部嵌入查找矩阵有更多控制权，将input_ids索引转换为相关向量来说很有用。 - image_text_alignment （
torch.LongTensor形状为(batch_size, visual_seq_length, alignment_number)，可选）—— Image-Text alignment 用于决定视觉嵌入的位置ID。 - output_attentions （
bool，可选）—— 是否返回所有注意力层的注意力张量。详细信息请参阅返回张量下的attentions。 - output_hidden_states （
bool，可选）—— 是否返回所有层的隐藏状态。详细信息请参阅返回张量下的hidden_states。 - return_dict （
bool，可选）—— 是否返回一个 ModelOutput 而不是普通的元组。 - labels (
torch.LongTensorof shape(batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应为[0, ..., config.num_labels - 1]。对这些标签计算交叉熵损失。
返回值
transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)
transformers.modeling_outputs.SequenceClassifierOutput 或一系列 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含根据配置（VisualBertConfig）和输入的不同元素。
-
loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 分类（或回归，如果 config.num_labels==1）损失。 -
logits (
torch.FloatTensorof shape(batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（均在SoftMax之前）。 -
hidden_states（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_hidden_states=True或当config.output_hidden_states=True` 时返回）——torch.FloatTensor元组（如果一个模型具有嵌入层，则为嵌入层的输出，每个层的输出分隔开来）的形状为(batch_size, sequence_length, hidden_size)。模型在每个层的输出以及可选的初始嵌入输出。
-
attentions（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_attentions=True或当config.output_attentions=True` 时返回）——torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。注意软化后的注意力权重，用于在自注意力的头部中进行加权平均。
《VisualBertForVisualReasoning》的前向方法，覆盖了特殊方法 __call__。
尽管前向传递的食谱需要在函数内部定义，但应该调用`Module`实例而不是此函数，因为前者处理了前向和后向处理步骤，而后者则默默忽略它们。
示例
# 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.logitsVisualBertForRegionToPhraseAlignment
类 transformers.VisualBertForRegionToPhraseAlignment
< 源 >参数
- config (VisualBertConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化时，不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。
带有掩码语言建模头和顶层注意力层的VisualBert模型，用于区域到短语对齐，例如用于Flickr30实体任务。
此模型也是一种 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解所有与通用使用和行为相关的内容。
正向
< source >( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None visual_embeds: 可选 = None visual_attention_mask: 可选 = None visual_token_type_ids: 可选 = None image_text_alignment: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None region_to_phrase_position: 可选 = None labels: 可选 = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状(batch_size, sequence_length)) — 输入序列中词汇中标记索引。索引可以通过使用 AutoTokenizer 获取。详细信息请见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免在填充token索引上执行注意力的掩码。掩码值选择在[0, 1]：- 1表示未掩码的tokens，
- 0表示掩码的tokens。
- token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 段token索引，指示输入的第一部分和第二部分。索引选择在[0, 1]：- 0对应于句子A的token，
- 1对应于句子B的token。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列token在位置嵌入中的位置索引。选择在范围[0, config.max_position_embeddings - 1]内。 - 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 对于未掩码的标记，
- 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 而不是纯元组。 - 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 or tuple(torch.FloatTensor)
transformers.modeling_outputs.SequenceClassifierOutput 或一系列 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含根据配置（VisualBertConfig）和输入的不同元素。
-
loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 分类（或回归，如果 config.num_labels==1）损失。 -
logits (
torch.FloatTensorof shape(batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（均在SoftMax之前）。 -
hidden_states（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_hidden_states=True或当config.output_hidden_states=True` 时返回）——torch.FloatTensor元组（如果一个模型具有嵌入层，则为嵌入层的输出，每个层的输出分隔开来）的形状为(batch_size, sequence_length, hidden_size)。模型在每个层的输出以及可选的初始嵌入输出。
-
attentions（《torch.FloatTensor` 的元组（区域性`optional`)，当传递
output_attentions=True或当config.output_attentions=True` 时返回）——torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。注意软化后的注意力权重，用于在自注意力的头部中进行加权平均。
VisualBertForRegionToPhraseAlignment的前向方法，覆盖了__call__的特殊方法。
尽管前向传递的食谱需要在函数内部定义，但应该调用`Module`实例而不是此函数，因为前者处理了前向和后向处理步骤，而后者则默默忽略它们。
示例
# 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