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

使用技巧
- 开始使用 ViLT 的最快方法是查看示例 notebook(其中展示了推理和在自定义数据上进行微调)。
- ViLT 是一个将
pixel_values
和input_ids
作为输入的模型。可以使用 ViltProcessor 为模型准备数据。此处理器将图像处理器(用于图像模态)和分词器(用于语言模态)包装在一起。 - ViLT 使用各种尺寸的图像进行训练:作者将输入图像的较短边调整为 384,并将较长边限制在 640 以下,同时保持宽高比。为了使图像能够批量处理,作者使用了一个
pixel_mask
来指示哪些像素值是真实的,哪些是填充的。ViltProcessor 会自动为您创建此 mask。 - 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
可以表示的不同 token 的数量。 - 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 添加 bias。 - 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
class transformers.ViltImageProcessor
< source >( do_resize: bool = True size: typing.Dict[str, int] = None size_divisor: int = 32 resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = 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
, optional, defaults toResampling.BICUBIC
) — 如果调整图像大小,使用的重采样滤波器。仅当do_resize
设置为True
时有效。可以被preprocess
方法中的resample
参数覆盖。 - do_rescale (
bool
, optional, defaults toTrue
) — 是否按照指定的缩放因子rescale_factor
重缩放图像。可以被preprocess
方法中的do_rescale
参数覆盖。 - rescale_factor (
int
orfloat
, optional, defaults to1/255
) — 如果重缩放图像,使用的缩放因子。仅当do_rescale
设置为True
时有效。可以被preprocess
方法中的rescale_factor
参数覆盖。 - do_normalize (
bool
, optional, defaults toTrue
) — 是否归一化图像。可以被preprocess
方法中的do_normalize
参数覆盖。 可以被preprocess
方法中的do_normalize
参数覆盖。 - image_mean (
float
orList[float]
, optional, defaults toIMAGENET_STANDARD_MEAN
) — 如果归一化图像,使用的均值。这是一个浮点数或浮点数列表,其长度与图像通道数相同。可以被preprocess
方法中的image_mean
参数覆盖。 可以被preprocess
方法中的image_mean
参数覆盖。 - image_std (
float
orList[float]
, optional, defaults toIMAGENET_STANDARD_STD
) — 如果归一化图像,使用的标准差。这是一个浮点数或浮点数列表,其长度与图像通道数相同。可以被preprocess
方法中的image_std
参数覆盖。 可以被preprocess
方法中的image_std
参数覆盖。 - do_pad (
bool
, optional, defaults toTrue
) — 是否将图像填充到批次中图像的(max_height, max_width)
。可以被preprocess
方法中的do_pad
参数覆盖。
构建 ViLT 图像处理器。
preprocess
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: typing.Optional[bool] = None size: typing.Optional[typing.Dict[str, int]] = None size_divisor: typing.Optional[int] = None resample: Resampling = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_pad: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )
参数
- images (
ImageInput
) — 要预处理的图像。期望像素值范围为 0 到 255 的单张或批量图像。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 - do_resize (
bool
, optional, defaults toself.do_resize
) — 是否调整图像大小。 - size (
Dict[str, int]
, optional, defaults toself.size
) — 控制 `resize` 之后图像的大小。图像的最短边将被调整为size["shortest_edge"]
,同时保持宽高比。如果调整大小后的图像的最长边 > `int(size["shortest_edge"] * (1333 / 800))`,则再次调整图像大小,使最长边等于 `int(size["shortest_edge"] * (1333 / 800))`。 - size_divisor (
int
, optional, defaults toself.size_divisor
) — 图像将被调整为该值的倍数大小。 - resample (
PILImageResampling
, optional, defaults toself.resample
) — 如果调整图像大小,使用的重采样滤波器。仅当do_resize
设置为True
时有效。 - do_rescale (
bool
, optional, defaults toself.do_rescale
) — 是否将图像值重缩放到 [0 - 1] 之间。 - rescale_factor (
float
, optional, defaults toself.rescale_factor
) — 如果do_rescale
设置为True
,则按照此重缩放因子重缩放图像。 - do_normalize (
bool
, optional, defaults toself.do_normalize
) — 是否归一化图像。 - image_mean (
float
orList[float]
, optional, defaults toself.image_mean
) — 如果do_normalize
设置为True
,则使用此图像均值归一化图像。 - image_std (
float
orList[float]
, optional, defaults toself.image_std
) — 如果do_normalize
设置为True
,则使用此图像标准差归一化图像。 - do_pad (
bool
, optional, defaults toself.do_pad
) — 是否将图像填充到批次中的 `(max_height, max_width)`。如果为True
,则还会创建并返回像素掩码。 - return_tensors (
str
orTensorType
, optional) — 要返回的张量类型。可以是以下之一:- 未设置:返回
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 (
ChannelDimension
orstr
, optional, defaults toChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:ChannelDimension.FIRST
: `(num_channels, height, width)` 格式的图像。ChannelDimension.LAST
: `(height, width, num_channels)` 格式的图像。
- input_data_format (
ChannelDimension
orstr
, optional) — 输入图像的通道维度格式。如果未设置,则通道维度格式将从输入图像中推断。可以是以下之一:"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
, optional) — ViltImageProcessor 的一个实例。图像处理器是必需的输入。 - tokenizer (
BertTokenizerFast
, optional) — [‘BertTokenizerFast`]. 的一个实例。分词器是必需的输入。
构建一个 ViLT 处理器,它将 BERT 分词器和 ViLT 图像处理器包装成单个处理器。
ViltProcessor 提供了 ViltImageProcessor 和 BertTokenizerFast 的所有功能。 有关更多信息,请参阅 call() 和 decode()
的文档字符串。
__call__
< source >( images text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = 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: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = 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: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None image_token_type_idx: typing.Optional[int] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
({0})
的torch.LongTensor
) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID? - attention_mask (形状为
({0})
的torch.FloatTensor
,可选) — 用于避免对填充标记索引执行注意力的掩码。在[0, 1]
中选择的掩码值:- 1 表示未被掩盖的标记,
- 0 表示被掩盖的标记。 什么是注意力掩码?
- token_type_ids (形状为
({0})
的torch.LongTensor
,可选) — 分段标记索引,用于指示输入的第一部分和第二部分。 索引在[0, 1]
中选择:- 0 对应于句子 A 标记,
- 1 对应于句子 B 标记。 什么是标记类型 ID?
- pixel_values (形状为
(batch_size, num_channels, height, width)
的torch.FloatTensor
) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息,请参阅 ViltImageProcessor.call()。 - pixel_mask (形状为
(batch_size, height, width)
的torch.LongTensor
,可选) — 用于避免对填充像素值执行注意力的掩码。在[0, 1]
中选择的掩码值:- 1 表示真实像素(即未被掩盖),
- 0 表示填充像素(即被掩盖)。
什么是注意力掩码? <../glossary.html#attention-mask>
__
- head_mask (形状为
(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选) — 用于使自注意力模块的选定头部无效的掩码。在[0, 1]
中选择的掩码值:- 1 表示头部未被掩盖,
- 0 表示头部被掩盖。
- 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
转换为补丁嵌入更好地进行控制,这将非常有用。 - 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
时),包括取决于配置 (ViltConfig) 和输入的各种元素。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (形状为
(batch_size, hidden_size)
的torch.FloatTensor
) — 序列的第一个标记(分类标记)的最后一层隐藏状态,在通过用于辅助预训练任务的层进行进一步处理之后。 例如,对于 BERT 系列模型,这将返回通过线性层和 tanh 激活函数处理后的分类标记。 线性层权重是通过预训练期间的下一个句子预测(分类)目标训练的。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(如果模型具有嵌入层,则一个用于嵌入的输出,+ 每个层的输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
的元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
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: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 IDs? - attention_mask (形状为
(batch_size, sequence_length)
的torch.FloatTensor
, 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示未被掩盖的标记,
- 0 表示被掩盖的标记。 什么是注意力掩码?
- token_type_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
, 可选) — 分段标记索引以指示输入的第一个和第二个部分。索引在[0, 1]
中选择:- 0 对应于 句子 A 标记,
- 1 对应于 句子 B 标记。 什么是标记类型 IDs?
- pixel_values (形状为
(batch_size, num_channels, height, width)
的torch.FloatTensor
) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息,请参见 ViltImageProcessor.call()。 - pixel_mask (形状为
(batch_size, height, width)
的torch.LongTensor
, 可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示真实的像素(即未被掩盖),
- 0 表示填充像素(即被掩盖)。
什么是注意力掩码? <../glossary.html#attention-mask>
__
- head_mask (形状为
(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
, 可选) — 用于使自注意力模块的选定头无效的掩码。掩码值在[0, 1]
中选择:- 1 表示头未被掩盖,
- 0 表示头被掩盖。
- inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
, 可选) — (可选)您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您想要比模型的内部嵌入查找矩阵更好地控制如何将input_ids
索引转换为关联的向量,这将非常有用。 - image_embeds (形状为
(batch_size, num_patches, hidden_size)
的torch.FloatTensor
, 可选) — (可选)您可以选择直接传递嵌入表示,而不是传递pixel_values
。如果您想要更好地控制如何将pixel_values
转换为补丁嵌入,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 用于计算掩码语言建模损失的标签。索引应为 [-100, 0, …, config.vocab_size] (请参阅 input_ids 文档字符串) 索引设置为 -100 的标记将被忽略(掩盖),损失仅针对标签在 [0, …, config.vocab_size] 中的标记计算
返回值
transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MaskedLMOutput 或一个 torch.FloatTensor
元组(如果传递 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (ViltConfig) 和输入。
-
loss (形状为
(1,)
的torch.FloatTensor
, 可选, 当提供labels
时返回) — 掩码语言建模 (MLM) 损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
) — 语言建模头的预测分数(SoftMax 之前每个词汇表标记的分数)。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(如果模型具有嵌入层,则一个用于嵌入的输出,+ 每个层的输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
的元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
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 模型转换器,顶部带有一个分类器头([CLS] 标记的最终隐藏状态顶部的线性层),用于视觉问答,例如用于 VQAv2。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.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 代表 未被 mask 的 tokens,
- 0 代表 已被 mask 的 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 代表真实的像素 (即 未被 mask),
- 0 代表 padding 像素 (即 已被 mask)。
什么是 attention masks? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
, 形状:(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于 nullify self-attention 模块中选定 heads 的 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
。如果您想要比模型的内部 patch 嵌入更精细地控制如何将pixel_values
转换为 patch 嵌入,这将非常有用。 - 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)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(如果模型具有嵌入层,则一个用于嵌入的输出,+ 每个层的输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
的元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
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
< source >( config )
参数
- 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 代表 未被 mask 的 tokens,
- 0 代表 已被 mask 的 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 代表真实的像素 (即 未被 mask),
- 0 代表 padding 像素 (即 已被 mask)。
什么是 attention masks? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
, 形状:(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于 nullify self-attention 模块中选定 heads 的 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_images, num_patches, hidden_size)
, 可选) — (可选) 您可以选择直接传递嵌入表示,而不是传递pixel_values
。如果您想要比模型的内部 patch 嵌入更精细地控制如何将pixel_values
转换为 patch 嵌入,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息,请参见返回 tensors 下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参见返回 tensors 下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是纯 tuple。
Vilt 模型 Transformer,顶部带有一个分类器头,用于自然语言视觉推理,例如 NLVR2。
forward
< 源码 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 IDs? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 掩码,用于避免在 padding token 索引上执行 attention。掩码值在[0, 1]
中选择:- 1 表示 tokens 未被掩盖,
- 0 表示 tokens 被掩盖。 什么是 attention 掩码?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:- 0 对应于 sentence A token,
- 1 对应于 sentence 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。掩码值在[0, 1]
中选择:- 1 表示像素是真实的(即未被掩盖),
- 0 表示像素是 padding(即被掩盖)。
什么是 attention 掩码? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 掩码,用于使 self-attention 模块的选定 head 无效。掩码值在[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 嵌入有更精细的控制,这将非常有用。 - output_attentions (
bool
,可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (
torch.LongTensor
,形状为(batch_size,)
,可选) — 二分类标签。
返回值
transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
或一个 torch.FloatTensor
元组(如果传递了 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
元组的列表(每个图像-文本对一个元组,每个元组包含嵌入的输出 + 每层输出),形状为(batch_size, sequence_length, hidden_size)
。 模型在每一层输出的隐藏状态,加上初始嵌入输出。 - attentions (
List[tuple(torch.FloatTensor)]
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组的列表(每个图像-文本对一个元组,每个元组包含形状为(batch_size, num_heads, sequence_length, sequence_length)
的 attention 权重。 attention softmax 之后的 Attention 权重,用于计算 self-attention head 中的加权平均值。
ViltForImagesAndTextClassification 前向传播方法,覆盖了 __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
class transformers.ViltForImageAndTextRetrieval
< 源码 >( config )
参数
- config (ViltConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
Vilt 模型转换器,顶部带有一个分类器头([CLS] 令牌的最终隐藏状态之上的线性层),用于图像到文本或文本到图像的检索,例如 MSCOCO 和 F30K。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< 源码 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 IDs? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 掩码,用于避免在 padding token 索引上执行 attention。掩码值在[0, 1]
中选择:- 1 表示 tokens 未被掩盖,
- 0 表示 tokens 被掩盖。 什么是 attention 掩码?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:- 0 对应于 sentence A token,
- 1 对应于 sentence 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。掩码值在[0, 1]
中选择:- 1 表示像素是真实的(即未被掩盖),
- 0 表示像素是 padding(即被掩盖)。
什么是 attention 掩码? <../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 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)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(如果模型具有嵌入层,则一个用于嵌入的输出,+ 每个层的输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
的元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
ViltForImageAndTextRetrieval 的 forward 方法,覆盖了 __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
< source >( config )
参数
- config (ViltConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有 token classification head 的 ViLT 模型(文本 token 的最终隐藏状态之上的线性层),例如用于命名实体识别 (NER) 任务。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
({0})
的torch.LongTensor
) — 词汇表中输入序列 token 的索引。 索引可以使用 AutoTokenizer 获得。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 IDs? - attention_mask (形状为
({0})
的torch.FloatTensor
, 可选) — 避免对 padding token 索引执行 attention 的掩码。 掩码值在[0, 1]
中选择:- 1 表示 token 不被掩盖,
- 0 表示 token 被掩盖。 什么是 attention 掩码?
- 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 像素值执行 attention 的掩码。 掩码值在[0, 1]
中选择:- 1 表示像素是真实的(即未被掩盖),
- 0 表示像素是 padding(即被掩盖)。
什么是 attention 掩码? <../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 embeddings,这将非常有用。 - 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)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(如果模型具有嵌入层,则一个用于嵌入的输出,+ 每个层的输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
的元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
ViltForTokenClassification 的 forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数内定义,但应在之后调用 Module
实例,而不是调用此函数,因为前者负责运行预处理和后处理步骤,而后者则会静默地忽略它们。