ViLT
概述
ViLT 模型由 Wonjae Kim、Bokyung Son 和 Ildoo Kim 在 ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision 中提出。ViLT 将文本嵌入整合到 Vision Transformer (ViT) 中,使其在视觉和语言预训练 (VLP) 中具有极简设计。
该论文的摘要如下:
视觉和语言预训练 (VLP) 提高了各种联合视觉和语言下游任务的性能。当前 VLP 方法在很大程度上依赖于图像特征提取过程,其中大多数过程涉及区域监督(例如,对象检测)和卷积架构(例如,ResNet)。尽管在文献中被忽视,但我们发现它在以下两个方面存在问题:(1) 效率/速度,即简单地提取输入特征比多模态交互步骤需要更多的计算;(2) 表达能力,因为它受限于视觉嵌入器及其预定义的视觉词汇的表达能力上限。在本文中,我们提出了一个极简的 VLP 模型,即视觉和语言 Transformer (ViLT),它在视觉输入处理方面是单片的,被大幅简化为与我们处理文本输入相同的方式,即无卷积方式。我们表明,ViLT 比以前的 VLP 模型快达数十倍,但下游任务性能具有竞争力或更好。

使用技巧
- 开始使用 ViLT 的最快方法是查看示例笔记本(其中展示了在自定义数据上进行推理和微调)。
- ViLT 是一个同时接受
pixel_values
和input_ids
作为输入的模型。可以使用 ViltProcessor 为模型准备数据。此处理器将图像处理器(用于图像模态)和分词器(用于语言模态)封装在一起。 - ViLT 使用各种尺寸的图像进行训练:作者将输入图像的较短边调整为 384,并将较长边限制在 640 以下,同时保持纵横比。为了使图像能够进行批量处理,作者使用了
pixel_mask
来指示哪些像素值是真实的,哪些是填充的。ViltProcessor 会自动为您创建此项。 - ViLT 的设计与标准 Vision Transformer (ViT) 的设计非常相似。唯一的区别是该模型包含用于语言模态的额外嵌入层。
- 此模型的 PyTorch 版本仅在 torch 1.10 及更高版本中可用。
ViltConfig
class transformers.ViltConfig
< source >( vocab_size = 30522 type_vocab_size = 2 modality_type_vocab_size = 2 max_position_embeddings = 40 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = 384 patch_size = 32 num_channels = 3 qkv_bias = True max_image_length = -1 tie_word_embeddings = False num_images = -1 **kwargs )
参数
- vocab_size (
int
, 可选, 默认为 30522) — 模型文本部分的词汇表大小。定义了在调用 ViltModel 时传递的inputs_ids
可以表示的不同标记的数量。 - type_vocab_size (
int
, 可选, 默认为 2) — 调用 ViltModel 时传递的token_type_ids
的词汇表大小。这在编码文本时使用。 - modality_type_vocab_size (
int
, 可选, 默认为 2) — 调用 ViltModel 时传递的模态的词汇表大小。这在连接文本和图像模态的嵌入后使用。 - max_position_embeddings (
int
, 可选, 默认为 40) — 此模型可能使用的最大序列长度。 - hidden_size (
int
, 可选, 默认为 768) — 编码器层和池化器层的维度。 - 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.0) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
float
, 可选, 默认为 0.0) — 注意力概率的 dropout 率。 - initializer_range (
float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float
, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。 - image_size (
int
, 可选, 默认为 384) — 每个图像的大小(分辨率)。 - patch_size (
int
, 可选, 默认为 32) — 每个 patch 的大小(分辨率)。 - num_channels (
int
, 可选, 默认为 3) — 输入通道数。 - qkv_bias (
bool
, 可选, 默认为True
) — 是否向 queries、keys 和 values 添加偏置。 - max_image_length (
int
, 可选, 默认为 -1) — 作为 Transformer 编码器输入的 patch 的最大数量。如果设置为正整数,则编码器最多将采样max_image_length
个 patch。如果设置为 -1,则不考虑。 - num_images (
int
, 可选, 默认为 -1) — 用于自然语言视觉推理的图像数量。如果设置为正整数,则 ViltForImagesAndTextClassification 将使用它来定义分类器头。
这是用于存储 ViLTModel
配置的配置类。它用于根据指定的参数实例化 ViLT 模型,定义模型架构。使用默认值实例化配置将产生与 ViLT dandelin/vilt-b32-mlm 架构类似的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。有关更多信息,请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import ViLTModel, ViLTConfig
>>> # Initializing a ViLT dandelin/vilt-b32-mlm style configuration
>>> configuration = ViLTConfig()
>>> # Initializing a model from the dandelin/vilt-b32-mlm style configuration
>>> model = ViLTModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
ViltFeatureExtractor
预处理一张图像或一批图像。
ViltImageProcessor
类 transformers.ViltImageProcessor
< source >( do_resize: bool = True size: Dict = None size_divisor: int = 32 resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )
参数
- **do_resize** (`bool`, *可选的*, 默认为 `True`) — 是否将图像的(高度,宽度)尺寸调整为指定的 `size` 大小。可以通过 `preprocess` 方法中的 `do_resize` 参数覆盖。
- **size** (`Dict[str, int]` *可选的*, 默认为 `{"shortest_edge": 384}`):将输入图像的较短边调整为 `size["shortest_edge"]` 大小。较长边将在保持宽高比的同时限制在 `int((1333 / 800) * size["shortest_edge"])` 以下。仅当 `do_resize` 设置为 `True` 时有效。可以通过 `preprocess` 方法中的 `size` 参数覆盖。
- **size_divisor** (`int`, *可选的*, 默认为 32) — 确保高度和宽度都可以被整除的尺寸大小。仅当 `do_resize` 设置为 `True` 时有效。可以通过 `preprocess` 方法中的 `size_divisor` 参数覆盖。
- **resample** (`PILImageResampling`, *可选的*, 默认为 `Resampling.BICUBIC`) — 如果调整图像大小,则使用的重采样滤波器。仅当 `do_resize` 设置为 `True` 时有效。可以通过 `preprocess` 方法中的 `resample` 参数覆盖。
- **do_rescale** (`bool`, *可选的*, 默认为 `True`) — 是否按照指定的比例 `rescale_factor` 重新缩放图像。可以通过 `preprocess` 方法中的 `do_rescale` 参数覆盖。
- **rescale_factor** (`int` 或 `float`, *可选的*, 默认为 `1/255`) — 如果重新缩放图像,则使用的缩放因子。仅当 `do_rescale` 设置为 `True` 时有效。可以通过 `preprocess` 方法中的 `rescale_factor` 参数覆盖。
- **do_normalize** (`bool`, *可选的*, 默认为 `True`) — 是否对图像进行归一化。可以通过 `preprocess` 方法中的 `do_normalize` 参数覆盖。可以通过 `preprocess` 方法中的 `do_normalize` 参数覆盖。
- **image_mean** (`float` 或 `List[float]`, *可选的*, 默认为 `IMAGENET_STANDARD_MEAN`) — 如果对图像进行归一化,则使用的均值。这是一个浮点数或浮点数列表,其长度是图像中通道的数量。可以通过 `preprocess` 方法中的 `image_mean` 参数覆盖。可以通过 `preprocess` 方法中的 `image_mean` 参数覆盖。
- **image_std** (`float` 或 `List[float]`, *可选的*, 默认为 `IMAGENET_STANDARD_STD`) — 如果对图像进行归一化,则使用的标准差。这是一个浮点数或浮点数列表,其长度是图像中通道的数量。可以通过 `preprocess` 方法中的 `image_std` 参数覆盖。可以通过 `preprocess` 方法中的 `image_std` 参数覆盖。
- **do_pad** (`bool`, *可选的*, 默认为 `True`) — 是否将图像填充到批次中图像的 `(max_height, max_width)` 大小。可以通过 `preprocess` 方法中的 `do_pad` 参数覆盖。
构建 ViLT 图像处理器。
preprocess
< source >( images: Union do_resize: Optional = None size: Optional = None size_divisor: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )
参数
- **images** (`ImageInput`) — 要预处理的图像。期望是像素值范围从 0 到 255 的单张或一批图像。如果传入的图像像素值在 0 到 1 之间,请设置 `do_rescale=False`。
- **do_resize** (`bool`, *可选的*, 默认为 `self.do_resize`) — 是否调整图像大小。
- **size** (`Dict[str, int]`, *可选的*, 默认为 `self.size`) — 控制调整大小后的图像尺寸。图像的最短边将调整为 `size["shortest_edge"]` 大小,同时保持宽高比。如果调整大小后的图像的最长边 > `int(size["shortest_edge"] * (1333 / 800))`,则再次调整图像大小,使最长边等于 `int(size["shortest_edge"] * (1333 / 800))`。
- **size_divisor** (`int`, *可选的*, 默认为 `self.size_divisor`) — 图像将被调整为该值的倍数的尺寸。
- **resample** (`PILImageResampling`, *可选的*, 默认为 `self.resample`) — 如果调整图像大小,则使用的重采样滤波器。仅当 `do_resize` 设置为 `True` 时有效。
- **do_rescale** (`bool`, *可选的*, 默认为 `self.do_rescale`) — 是否将图像值重新缩放到 [0 - 1] 之间。
- **rescale_factor** (`float`, *可选的*, 默认为 `self.rescale_factor`) — 如果 `do_rescale` 设置为 `True`,则用于重新缩放图像的缩放因子。
- **do_normalize** (`bool`, *可选的*, 默认为 `self.do_normalize`) — 是否对图像进行归一化。
- **image_mean** (`float` 或 `List[float]`, *可选的*, 默认为 `self.image_mean`) — 如果 `do_normalize` 设置为 `True`,则用于归一化图像的图像均值。
- **image_std** (`float` 或 `List[float]`, *可选的*, 默认为 `self.image_std`) — 如果 `do_normalize` 设置为 `True`,则用于归一化图像的图像标准差。
- **do_pad** (`bool`, *可选的*, 默认为 `self.do_pad`) — 是否将图像填充到批次中的 `(max_height, max_width)` 大小。如果为 `True`,则还会创建并返回像素掩码。
- return_tensors (
str
或TensorType
, 可选) — 返回的张量类型。可以是以下之一:- Unset: 返回
np.ndarray
列表。 TensorType.TENSORFLOW
或'tf'
: 返回tf.Tensor
类型的批次。TensorType.PYTORCH
或'pt'
: 返回torch.Tensor
类型的批次。TensorType.NUMPY
或'np'
: 返回np.ndarray
类型的批次。TensorType.JAX
或'jax'
: 返回jax.numpy.ndarray
类型的批次。
- Unset: 返回
- data_format (
ChannelDimension
或str
, 可选, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:ChannelDimension.FIRST
: 图像格式为 (num_channels, height, width)。ChannelDimension.LAST
: 图像格式为 (height, width, num_channels)。
- input_data_format (
ChannelDimension
或str
, 可选) — 输入图像的通道维度格式。如果未设置,则通道维度格式将从输入图像中推断。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
: 图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
: 图像格式为 (height, width, num_channels)。"none"
或ChannelDimension.NONE
: 图像格式为 (height, width)。
预处理单张或批量图像。
ViltProcessor
class transformers.ViltProcessor
< source >( image_processor = None tokenizer = None **kwargs )
参数
- image_processor (
ViltImageProcessor
, 可选) — ViltImageProcessor 的一个实例。图像处理器是必需的输入。 - tokenizer (
BertTokenizerFast
, 可选) — [‘BertTokenizerFast`] 的一个实例。分词器是必需的输入。
构建一个 ViLT 处理器,它将 BERT 分词器和 ViLT 图像处理器封装到一个处理器中。
ViltProcessor 提供了 ViltImageProcessor 和 BertTokenizerFast 的所有功能。有关更多信息,请参阅 call() 和 decode()
的文档字符串。
__call__
< source >( images text: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: Union = None **kwargs )
此方法使用 ViltImageProcessor.call() 方法为模型准备图像,并使用 BertTokenizerFast.call() 为模型准备文本。
有关更多信息,请参阅上述两种方法的文档字符串。
ViltModel
class transformers.ViltModel
< source >( config add_pooling_layer = True )
参数
- config (ViltConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。
裸 ViLT 模型 Transformer 输出原始隐藏状态,顶部没有任何特定的头部。此模型是一个 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None image_token_type_idx: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
({0})
的torch.LongTensor
) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获得索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 IDs? - attention_mask (形状为
({0})
的torch.FloatTensor
, 可选) — 掩码,用于避免在 padding token 索引上执行注意力机制。掩码值在[0, 1]
中选择:- 1 表示 token 未被掩盖,
- 0 表示 token 被掩盖。什么是注意力掩码?
- token_type_ids (形状为
({0})
的torch.LongTensor
, 可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。什么是 token 类型 IDs?
- pixel_values (形状为
(batch_size, num_channels, height, width)
的torch.FloatTensor
) — 像素值。可以使用 AutoImageProcessor 获得像素值。有关详细信息,请参阅 ViltImageProcessor.call()。 - pixel_mask (形状为
(batch_size, height, width)
的torch.LongTensor
, 可选) — 掩码,用于避免在 padding 像素值上执行注意力机制。掩码值在[0, 1]
中选择:- 1 表示像素是真实的(即未被掩盖),
- 0 表示像素是 padding(即被掩盖)。
什么是注意力掩码? <../glossary.html#attention-mask>
__
- head_mask (形状为
(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
, 可选) — 掩码,用于使自注意力模块的选定 head 失效。掩码值在[0, 1]
中选择:- 1 表示 head 未被掩盖,
- 0 表示 head 被掩盖。
- inputs_embeds (形状为
({0}, hidden_size)
的torch.FloatTensor
, 可选) — (可选)您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - image_embeds (形状为
(batch_size, num_patches, hidden_size)
的torch.FloatTensor
, 可选) — (可选)您可以选择直接传递嵌入表示,而不是传递pixel_values
。如果您希望更好地控制如何将pixel_values
转换为 patch 嵌入,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor
元组 (如果传递了 return_dict=False
或者当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (ViltConfig) 和输入。
-
last_hidden_state (
torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的输出端的隐藏状态序列。 -
pooler_output (
torch.FloatTensor
,形状为(batch_size, hidden_size)
) — 序列的第一个 token (分类 token) 的最后一层隐藏状态,在通过用于辅助预训练任务的层进一步处理之后。例如,对于 BERT 系列模型,这返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重通过预训练期间的下一句预测 (分类) 目标进行训练。 -
hidden_states (
tuple(torch.FloatTensor)
, optional, 当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组 (如果模型有嵌入层,则为嵌入输出,+ 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出端的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, optional, 当传递了output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
的元组 (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
ViltModel 的 forward 方法,覆盖了 __call__
特殊方法。
虽然 forward 传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例
>>> from transformers import ViltProcessor, ViltModel
>>> from PIL import Image
>>> import requests
>>> # prepare image and text
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "hello world"
>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-mlm")
>>> model = ViltModel.from_pretrained("dandelin/vilt-b32-mlm")
>>> inputs = processor(image, text, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
ViltForMaskedLM
class transformers.ViltForMaskedLM
< source >( config )
参数
- config (ViltConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。
带有语言建模头的 ViLT 模型,在预训练期间完成。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.MaskedLMOutput 或 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)
, optional) — 掩码,用于避免在 padding token 索引上执行注意力。掩码值在[0, 1]
中选择:- 1 表示 token 未被掩盖,
- 0 表示 token 被掩盖。 什么是注意力掩码?
- token_type_ids (
torch.LongTensor
,形状为(batch_size, sequence_length)
, optional) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。 什么是 token 类型 ID?
- pixel_values (
torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 AutoImageProcessor 获取。 有关详细信息,请参阅 ViltImageProcessor.call()。 - pixel_mask (
torch.LongTensor
,形状为(batch_size, height, width)
, optional) — 掩码,用于避免在 padding 像素值上执行注意力。掩码值在[0, 1]
中选择:- 1 表示像素是真实的 (即未被掩盖),
- 0 表示像素是 padding (即被掩盖)。
什么是注意力掩码? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
, optional) — 掩码,用于使自注意力模块的选定头无效。掩码值在[0, 1]
中选择:- 1 表示头未被掩盖,
- 0 表示头被掩盖。
- inputs_embeds (
torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
, optional) — (可选)您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - image_embeds (
torch.FloatTensor
,形状为(batch_size, num_patches, hidden_size)
, optional) — (可选)您可以选择直接传递嵌入表示,而不是传递pixel_values
。如果您希望更好地控制如何将pixel_values
转换为 patch 嵌入,这将非常有用。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 而不是普通元组。 - labels (torch.LongTensor,形状为 (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, …, config.vocab_size] 中 (参见 input_ids 文档字符串) 索引设置为 -100 的 Token 将被忽略 (掩码),损失仅针对标签在 [0, …, config.vocab_size] 中的 Token 计算
返回值
transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MaskedLMOutput 或一个 torch.FloatTensor
元组 (如果传递了 return_dict=False
或者当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (ViltConfig) 和输入。
-
loss (
torch.FloatTensor
,形状为(1,)
, optional, 当提供labels
时返回) — 掩码语言建模 (MLM) 损失。 -
logits (
torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数 (SoftMax 之前每个词汇表 token 的分数)。 -
hidden_states (
tuple(torch.FloatTensor)
, optional, 当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组 (如果模型有嵌入层,则为嵌入输出,+ 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出端的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, optional, 当传递了output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
的元组 (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
ViltForMaskedLM 的 forward 方法,覆盖了 __call__
特殊方法。
虽然 forward 传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例
>>> from transformers import ViltProcessor, ViltForMaskedLM
>>> import requests
>>> from PIL import Image
>>> import re
>>> import torch
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "a bunch of [MASK] laying on a [MASK]."
>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-mlm")
>>> model = ViltForMaskedLM.from_pretrained("dandelin/vilt-b32-mlm")
>>> # prepare inputs
>>> encoding = processor(image, text, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**encoding)
>>> tl = len(re.findall("\[MASK\]", text))
>>> inferred_token = [text]
>>> # gradually fill in the MASK tokens, one by one
>>> with torch.no_grad():
... for i in range(tl):
... encoded = processor.tokenizer(inferred_token)
... input_ids = torch.tensor(encoded.input_ids)
... encoded = encoded["input_ids"][0][1:-1]
... outputs = model(input_ids=input_ids, pixel_values=encoding.pixel_values)
... mlm_logits = outputs.logits[0] # shape (seq_len, vocab_size)
... # only take into account text features (minus CLS and SEP token)
... mlm_logits = mlm_logits[1 : input_ids.shape[1] - 1, :]
... mlm_values, mlm_ids = mlm_logits.softmax(dim=-1).max(dim=-1)
... # only take into account text
... mlm_values[torch.tensor(encoded) != 103] = 0
... select = mlm_values.argmax().item()
... encoded[select] = mlm_ids[select].item()
... inferred_token = [processor.decode(encoded)]
>>> selected_token = ""
>>> encoded = processor.tokenizer(inferred_token)
>>> output = processor.decode(encoded.input_ids[0], skip_special_tokens=True)
>>> print(output)
a bunch of cats laying on a couch.
ViltForQuestionAnswering
class transformers.ViltForQuestionAnswering
< source >( config )
参数
- config (ViltConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。
带有分类器头的 ViLT 模型 Transformer (分类器头是 [CLS] token 的最终隐藏状态之上的线性层),用于视觉问答,例如用于 VQAv2。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids:可选 = None attention_mask:可选 = None token_type_ids:可选 = None pixel_values:可选 = None pixel_mask:可选 = None head_mask:可选 = None inputs_embeds:可选 = None image_embeds:可选 = None labels:可选 = None output_attentions:可选 = None output_hidden_states:可选 = None return_dict:可选 = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列 tokens 的索引。 索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是 input IDs? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 tokens 未被掩盖,
- 0 表示 tokens 已被掩盖。什么是 attention masks?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 片段 token 索引,用于指示输入的第一个和第二个部分。 索引在[0, 1]
中选择:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。什么是 token type IDs?
- pixel_values (
torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息,请参阅 ViltImageProcessor.call()。 - pixel_mask (
torch.LongTensor
,形状为(batch_size, height, width)
,可选) — 用于避免在 padding 像素值上执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示像素是真实的(即未被掩盖),
- 0 表示像素是 padding(即已被掩盖)。
什么是 attention masks? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 用于 nullify self-attention 模块的选定 head 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 head 未被掩盖,
- 0 表示 head 已被掩盖。
- inputs_embeds (
torch.FloatTensor
,形状为({0}, hidden_size)
,可选) — (可选)您可以选择直接传递嵌入表示,而不是传递input_ids
。 如果您想要比模型的内部嵌入查找矩阵更精细地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - image_embeds (
torch.FloatTensor
,形状为(batch_size, num_patches, hidden_size)
,可选) — (可选)您可以选择直接传递嵌入表示,而不是传递pixel_values
。 如果您想要更精细地控制如何将pixel_values
转换为 patch embeddings,这将非常有用。 - output_attentions (
bool
,可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息,请参见返回的 tensors 下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参见返回的 tensors 下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是纯粹的 tuple。 - labels (
torch.FloatTensor
,形状为(batch_size, num_labels)
,可选) — 用于计算视觉问答损失的标签。 此 tensor 必须是 batch 中给定示例的所有适用答案的 one-hot 编码,或者是指示哪些答案适用的 soft 编码,其中 1.0 是最高分。
返回值
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 或 torch.FloatTensor
的 tuple (如果传递了 return_dict=False
或当 config.return_dict=False
时),包含取决于配置 (ViltConfig) 和输入的各种元素。
-
loss (
torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果 config.num_labels==1,则为回归)损失。 -
logits (
torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类(如果 config.num_labels==1,则为回归)得分(在 SoftMax 之前)。 -
hidden_states (
tuple(torch.FloatTensor)
, optional, 当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组 (如果模型有嵌入层,则为嵌入输出,+ 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出端的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, optional, 当传递了output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
的元组 (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
ViltForQuestionAnswering 的 forward 方法,覆盖了 __call__
特殊方法。
虽然 forward 传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例
>>> from transformers import ViltProcessor, ViltForQuestionAnswering
>>> import requests
>>> from PIL import Image
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "How many cats are there?"
>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-vqa")
>>> model = ViltForQuestionAnswering.from_pretrained("dandelin/vilt-b32-finetuned-vqa")
>>> # prepare inputs
>>> encoding = processor(image, text, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**encoding)
>>> logits = outputs.logits
>>> idx = logits.argmax(-1).item()
>>> print("Predicted answer:", model.config.id2label[idx])
Predicted answer: 2
ViltForImagesAndTextClassification
class transformers.ViltForImagesAndTextClassification
< 源代码 >( config )
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列 tokens 的索引。 索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是 input IDs? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 tokens 未被掩盖,
- 0 表示 tokens 已被掩盖。什么是 attention masks?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 片段 token 索引,用于指示输入的第一个和第二个部分。 索引在[0, 1]
中选择:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。什么是 token type IDs?
- pixel_values (
torch.FloatTensor
,形状为(batch_size, num_images, num_channels, height, width)
) — 像素值。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息,请参阅 ViltImageProcessor.call()。 - pixel_mask (
torch.LongTensor
,形状为(batch_size, num_images, height, width)
,可选) — 用于避免在 padding 像素值上执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示像素是真实的(即未被掩盖),
- 0 表示像素是 padding(即已被掩盖)。
什么是 attention masks? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 用于 nullify self-attention 模块的选定 head 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 head 未被掩盖,
- 0 表示 head 已被掩盖。
- inputs_embeds (
torch.FloatTensor
,形状为({0}, hidden_size)
,可选) — (可选)您可以选择直接传递嵌入表示,而不是传递input_ids
。 如果您想要比模型的内部嵌入查找矩阵更精细地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - image_embeds (
torch.FloatTensor
,形状为(batch_size, num_images, num_patches, hidden_size)
,可选) — (可选)您可以选择直接传递嵌入表示,而不是传递pixel_values
。 如果您想要更精细地控制如何将pixel_values
转换为 patch embeddings,这将非常有用。 - output_attentions (
bool
,可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息,请参见返回的 tensors 下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参见返回的 tensors 下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是纯粹的 tuple。
Vilt 模型转换器,顶部带有分类器 head,用于自然语言视觉推理,例如 NLVR2。
forward
< source >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。 什么是输入 IDs? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 token 未被 mask,
- 0 表示 token 已被 mask。 什么是 attention mask?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。 索引在[0, 1]
中选择:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。 什么是 token 类型 IDs?
- pixel_values (
torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。 像素值可以使用 AutoImageProcessor 获得。 请参阅 ViltImageProcessor.call() 以了解详情。 - pixel_mask (
torch.LongTensor
,形状为(batch_size, height, width)
,可选) — 用于避免在 padding 像素值上执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示像素是真实的(即未被 mask),
- 0 表示像素是 padding(即已被 mask)。
什么是 attention mask? <../glossary.html#attention-mask>
__
- 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
,形状为({0}, hidden_size)
,可选) — (可选)您可以选择直接传递嵌入表示,而不是传递input_ids
。 如果您想要比模型的内部嵌入查找矩阵更精细地控制如何将input_ids
索引转换为关联向量,这将非常有用。 - image_embeds (
torch.FloatTensor
,形状为(batch_size, num_patches, hidden_size)
,可选) — (可选)您可以选择直接传递嵌入表示,而不是传递pixel_values
。 如果您想要比如何将pixel_values
转换为 patch embeddings 更精细地控制,这将非常有用。 - output_attentions (
bool
,可选) — 是否返回所有 attention 层的 attention tensors。 有关更多详细信息,请参阅返回的 tensors 下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回的 tensors 下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通 tuple。 - labels (
torch.LongTensor
,形状为(batch_size,)
,可选) — 二分类标签。
返回值
transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
或一个 torch.FloatTensor
的 tuple (如果传递 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (ViltConfig) 和输入。
- loss (
torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果 config.num_labels==1,则为回归)损失。 - logits (
torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类(如果 config.num_labels==1,则为回归)得分(在 SoftMax 之前)。 - hidden_states (
List[tuple(torch.FloatTensor)]
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
的 tuple 列表 (每个图像-文本对一个 tuple,每个 tuple 包含 embeddings 的输出 + 每个层的输出一个 tuple),形状为(batch_size, sequence_length, hidden_size)
。 模型在每一层输出的 hidden-states 加上初始 embedding 输出。 - attentions (
List[tuple(torch.FloatTensor)]
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
的 tuple 列表 (每个图像-文本对一个 tuple,每个 tuple 包含 attention 权重,形状为(batch_size, num_heads, sequence_length, sequence_length)
。 attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。
ViltForImagesAndTextClassification forward 方法,覆盖了 __call__
特殊方法。
虽然 forward 传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例
>>> from transformers import ViltProcessor, ViltForImagesAndTextClassification
>>> import requests
>>> from PIL import Image
>>> image1 = Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg", stream=True).raw)
>>> image2 = Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_1.jpg", stream=True).raw)
>>> text = "The left image contains twice the number of dogs as the right image."
>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-nlvr2")
>>> model = ViltForImagesAndTextClassification.from_pretrained("dandelin/vilt-b32-finetuned-nlvr2")
>>> # prepare inputs
>>> encoding = processor([image1, image2], text, return_tensors="pt")
>>> # forward pass
>>> outputs = model(input_ids=encoding.input_ids, pixel_values=encoding.pixel_values.unsqueeze(0))
>>> logits = outputs.logits
>>> idx = logits.argmax(-1).item()
>>> print("Predicted answer:", model.config.id2label[idx])
Predicted answer: True
ViltForImageAndTextRetrieval
类 transformers.ViltForImageAndTextRetrieval
< source >( config )
参数
- config (ViltConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
Vilt 模型 Transformer,顶部带有一个分类器 head([CLS] token 的最终 hidden state 之上的一个线性层),用于图像到文本或文本到图像的检索,例如 MSCOCO 和 F30K。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids:可选 = None attention_mask:可选 = None token_type_ids:可选 = None pixel_values:可选 = None pixel_mask:可选 = None head_mask:可选 = None inputs_embeds:可选 = None image_embeds:可选 = None labels:可选 = None output_attentions:可选 = None output_hidden_states:可选 = None return_dict:可选 = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。 什么是输入 IDs? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示 token 未被 mask,
- 0 表示 token 已被 mask。 什么是 attention mask?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。 索引在[0, 1]
中选择:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。 什么是 token 类型 IDs?
- pixel_values (
torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。 像素值可以使用 AutoImageProcessor 获得。 请参阅 ViltImageProcessor.call() 以了解详情。 - pixel_mask (
torch.LongTensor
,形状为(batch_size, height, width)
,可选) — 用于避免在 padding 像素值上执行 attention 的 Mask。 Mask 值在[0, 1]
中选择:- 1 表示像素是真实的(即未被 mask),
- 0 表示像素是 padding(即已被 mask)。
什么是 attention mask? <../glossary.html#attention-mask>
__
- 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
,形状为({0}, hidden_size)
,可选) — (可选)您可以选择直接传递嵌入表示,而不是传递input_ids
。 如果您想要比模型的内部嵌入查找矩阵更精细地控制如何将input_ids
索引转换为关联向量,这将非常有用。 - image_embeds (
torch.FloatTensor
,形状为(batch_size, num_patches, hidden_size)
,可选) — (可选)您可以选择直接传递嵌入表示,而不是传递pixel_values
。 如果您想要比如何将pixel_values
转换为 patch embeddings 更精细地控制,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。详见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。详见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通的元组。 - labels (形状为
(batch_size,)
的torch.LongTensor
, 可选) — 当前不支持标签。
返回值
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 或 torch.FloatTensor
的 tuple (如果传递了 return_dict=False
或当 config.return_dict=False
时),包含取决于配置 (ViltConfig) 和输入的各种元素。
-
loss (
torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果 config.num_labels==1,则为回归)损失。 -
logits (
torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类(如果 config.num_labels==1,则为回归)得分(在 SoftMax 之前)。 -
hidden_states (
tuple(torch.FloatTensor)
, optional, 当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组 (如果模型有嵌入层,则为嵌入输出,+ 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出端的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, optional, 当传递了output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
的元组 (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
ViltForImageAndTextRetrieval 的前向传播方法覆盖了 __call__
特殊方法。
虽然 forward 传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例
>>> from transformers import ViltProcessor, ViltForImageAndTextRetrieval
>>> import requests
>>> from PIL import Image
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"]
>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-coco")
>>> model = ViltForImageAndTextRetrieval.from_pretrained("dandelin/vilt-b32-finetuned-coco")
>>> # forward pass
>>> scores = dict()
>>> for text in texts:
... # prepare inputs
... encoding = processor(image, text, return_tensors="pt")
... outputs = model(**encoding)
... scores[text] = outputs.logits[0, :].item()
ViltForTokenClassification
class transformers.ViltForTokenClassification
< 源代码 >( config )
参数
- config (ViltConfig) — 模型的配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法加载模型权重。
ViLT 模型,顶部带有一个 token 分类头(文本 token 的最终隐藏状态之上的线性层),例如用于命名实体识别 (NER) 任务。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
({0})
的torch.LongTensor
) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。 详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。 什么是输入 ID? - attention_mask (形状为
({0})
的torch.FloatTensor
, 可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在[0, 1]
中选择:- 1 表示 token 未被 mask,
- 0 表示 token 已被 mask。 什么是注意力 Mask?
- token_type_ids (形状为
({0})
的torch.LongTensor
, 可选) — Segment token 索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。 什么是 token 类型 ID?
- pixel_values (形状为
(batch_size, num_channels, height, width)
的torch.FloatTensor
) — 像素值。像素值可以使用 AutoImageProcessor 获得。 详见 ViltImageProcessor.call() 以了解详情。 - pixel_mask (形状为
(batch_size, height, width)
的torch.LongTensor
, 可选) — 用于避免在 padding 像素值上执行 attention 的 Mask。Mask 值在[0, 1]
中选择:- 1 表示像素是真实的(即 未被 mask),
- 0 表示像素是 padding(即 已被 mask)。
什么是注意力 Mask? <../glossary.html#attention-mask>
__
- head_mask (形状为
(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
, 可选) — 用于 nullify self-attention 模块中选定 head 的 Mask。Mask 值在[0, 1]
中选择:- 1 表示 head 未被 mask,
- 0 表示 head 已被 mask。
- inputs_embeds (形状为
({0}, hidden_size)
的torch.FloatTensor
, 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - image_embeds (形状为
(batch_size, num_patches, hidden_size)
的torch.FloatTensor
, 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递pixel_values
。如果您希望更精细地控制如何将pixel_values
转换为 patch 嵌入,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。详见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。详见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通的元组。 - labels (形状为
(batch_size, text_sequence_length)
的torch.LongTensor
, 可选) — 用于计算 token 分类损失的标签。索引应在[0, ..., config.num_labels - 1]
中。
返回值
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.TokenClassifierOutput 或 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (ViltConfig) 和输入。
-
loss (形状为
(1,)
的torch.FloatTensor
, 可选, 当提供labels
时返回) — 分类损失。 -
logits (形状为
(batch_size, sequence_length, config.num_labels)
的torch.FloatTensor
) — 分类得分(SoftMax 之前)。 -
hidden_states (
tuple(torch.FloatTensor)
, optional, 当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组 (如果模型有嵌入层,则为嵌入输出,+ 每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出端的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, optional, 当传递了output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
的元组 (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
ViltForTokenClassification 的前向传播方法覆盖了 __call__
特殊方法。
虽然 forward 传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。