Transformers 文档

ViLT

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

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 模型快达数十倍,但下游任务性能具有竞争力或更好。

drawing ViLT 架构。摘自原始论文

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

使用技巧

  • 开始使用 ViLT 的最快方法是查看示例笔记本(其中展示了在自定义数据上进行推理和微调)。
  • ViLT 是一个同时接受 pixel_valuesinput_ids 作为输入的模型。可以使用 ViltProcessor 为模型准备数据。此处理器将图像处理器(用于图像模态)和分词器(用于语言模态)封装在一起。
  • ViLT 使用各种尺寸的图像进行训练:作者将输入图像的较短边调整为 384,并将较长边限制在 640 以下,同时保持纵横比。为了使图像能够进行批量处理,作者使用了 pixel_mask 来指示哪些像素值是真实的,哪些是填充的。ViltProcessor 会自动为您创建此项。
  • ViLT 的设计与标准 Vision Transformer (ViT) 的设计非常相似。唯一的区别是该模型包含用于语言模态的额外嵌入层。
  • 此模型的 PyTorch 版本仅在 torch 1.10 及更高版本中可用。

ViltConfig

class transformers.ViltConfig

< >

( 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 (strfunction, 可选, 默认为 "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

transformers.ViltFeatureExtractor

< >

( *args **kwargs )

__call__

< >

( images **kwargs )

预处理一张图像或一批图像。

ViltImageProcessor

transformers.ViltImageProcessor

< >

( 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

< >

( 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 (strTensorType, 可选) — 返回的张量类型。可以是以下之一:
    • Unset: 返回 np.ndarray 列表。
    • TensorType.TENSORFLOW'tf': 返回 tf.Tensor 类型的批次。
    • TensorType.PYTORCH'pt': 返回 torch.Tensor 类型的批次。
    • TensorType.NUMPY'np': 返回 np.ndarray 类型的批次。
    • TensorType.JAX'jax': 返回 jax.numpy.ndarray 类型的批次。
  • data_format (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,则通道维度格式将从输入图像中推断。可以是以下之一:
    • "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

< >

( image_processor = None tokenizer = None **kwargs )

参数

  • image_processor (ViltImageProcessor, 可选) — ViltImageProcessor 的一个实例。图像处理器是必需的输入。
  • tokenizer (BertTokenizerFast, 可选) — [‘BertTokenizerFast`] 的一个实例。分词器是必需的输入。

构建一个 ViLT 处理器,它将 BERT 分词器和 ViLT 图像处理器封装到一个处理器中。

ViltProcessor 提供了 ViltImageProcessorBertTokenizerFast 的所有功能。有关更多信息,请参阅 call()decode() 的文档字符串。

__call__

< >

( 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

< >

( 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

< >

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

参数

  • input_ids (形状为 ({0})torch.LongTensor) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获得索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 IDs?
  • attention_mask (形状为 ({0})torch.FloatTensor, 可选) — 掩码,用于避免在 padding token 索引上执行注意力机制。掩码值在 [0, 1] 中选择:

  • token_type_ids (形状为 ({0})torch.LongTensor, 可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

  • 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.BaseModelOutputWithPoolingtuple(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

< >

( config )

参数

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

带有语言建模头的 ViLT 模型,在预训练期间完成。

此模型是 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.MaskedLMOutputtuple(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] 中选择:

  • token_type_ids (torch.LongTensor,形状为 (batch_size, sequence_length), optional) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

  • 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.MaskedLMOutputtuple(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

< >

( 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

< >

( 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.SequenceClassifierOutputtuple(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] 中选择:

  • token_type_ids (torch.LongTensor,形状为 ({0})可选) — 片段 token 索引,用于指示输入的第一个和第二个部分。 索引在 [0, 1] 中选择:

  • 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.SequenceClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutputtorch.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] 中选择:

  • token_type_ids (torch.LongTensor,形状为 ({0})可选) — 片段 token 索引,用于指示输入的第一个和第二个部分。 索引在 [0, 1] 中选择:

  • 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

< >

( 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] 中选择:

  • token_type_ids (torch.LongTensor,形状为 ({0})可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择:

  • 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.ViltForImagesAndTextClassificationOutputtuple(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

< >

( 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

< >

( 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.SequenceClassifierOutputtuple(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] 中选择:

  • token_type_ids (torch.LongTensor,形状为 ({0})可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择:

  • 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.SequenceClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutputtorch.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.TokenClassifierOutputtuple(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] 中选择:

  • token_type_ids (形状为 ({0})torch.LongTensor, 可选) — Segment token 索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

  • 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.TokenClassifierOutputtuple(torch.FloatTensor)

transformers.modeling_outputs.TokenClassifierOutputtorch.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 实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

< > 在 GitHub 上更新