ViLT 模型在 Wonjae Kim、Bokyung Son 和 Ildoo Kim 的论文《ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision》中被提出,见ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision。ViLT 将文本嵌入到视觉变压器 (ViT) 中,允许其对视觉和语言预训练 (VLP) 采用最小设计。
论文的摘要如下:
视觉与语言预训练(VLP)在各种联合视觉与语言下游任务上提高了性能。当前VLP方法在很大程度上依赖于图像特征提取过程,其中大多数涉及区域监督(例如,物体检测)和卷积架构(例如,ResNet)。虽然文献中未予考虑,但我们发现这存在问题,即(1)效率/速度,因为简单地提取输入特征的计算量比多模态交互步骤大得多;以及(2)表达能力,因为它被限制在视觉嵌入器和其预定义视觉词汇的表达能力之内。在这篇论文中,我们介绍了一个最小的VLP模型,视觉与语言变换器(ViLT),在整个模型中,处理视觉输入的方式被极大地简化,就像我们处理文本输入一样,没有任何卷积操作。我们表明,ViLT比以前的VLP模型快数十倍,而且下游任务性能具有竞争力甚至更好。
ViLT架构图。图片来自原始论文。使用提示
- 开始使用ViLT最快的方法是查看示例笔记本(展示了在自定义数据上的推理和微调)。
- ViLT是一个接收
pixel_values
和input_ids
作为输入的模型。可以使用ViltProcessor为模型准备数据。此处理器将图像处理器(用于图像模态)和分词器(用于语言模态)集成在一起。 - ViLT使用各种大小的图像进行训练:作者将输入图像较短的一边调整为384,并将较长的一边限制在640以下,同时保持比例。为了使图像批处理成为可能,作者使用了
pixel_mask
,它指示哪些像素值是真实的,哪些是填充。《a href="/docs/transformers/v4.44.0/en/model_doc/vilt#transformers.ViltProcessor">ViltProcessor会自动为您创建此内容。 - ViLT的设计与标准视觉变换器(ViT)的设计非常相似。唯一的区别是模型包含了额外的语言模态嵌入层。
- 此模型的PyTorch版本仅适用于torch 1.10及以上。
ViltConfig
类 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 (
字符串
或函数
,可选,默认为"gelu"
) — 编码器和池器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 - hidden_dropout_prob (
浮点数
,可选,默认为 0.0) — 在嵌入、编码器和池器中所有全连接层的dropout概率。 - attention_probs_dropout_prob (
浮点数
,可选,默认为 0.0) — 注意力概率的dropout比率。 - initializer_range (
浮点数
,可选,默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准偏差。 - layer_norm_eps (
float
,可选,默认为1e-12) — 层归一化层使用的epsilon值。 - image_size (
int
,可选,默认为384) — 每个图片的大小(分辨率)。 - patch_size (
int
,可选,默认为32) — 每个补丁的大小(分辨率)。 - num_channels (
int
,可选,默认为3) — 输入通道的数量。 - qkv_bias (
bool
, 可选, 默认为True
) — 是否为查询、键和值添加偏置。 - max_image_length (
int
, 可选, 默认为 -1) — Transformer 编码器输入的最大 patch 数。如果设置为正整数,则 encoder 最大将采样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.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
< source >( images: 并集 do_resize: 可选 = None size: 可选 = None size_divisor: 可选 = None resample: 重采样 = None do_rescale: 可选 = None rescale_factor: 可选 = None do_normalize: 可选 = None image_mean: 并集 = None image_std: 并集 = None do_pad: 可选 = None return_tensors: 并集 = None data_format: 通道维度 = <ChannelDimension.FIRST: 'channels_first'> input_data_format: 并集 = None )
参数
- images (
ImageInput
) — 预处理图像。期望是像素值范围为0至255的单个或批量图像。如果传入像素值在0和1之间的图像,设do_rescale=False
。 - do_resize (
布尔值
, 可选,默认为self.do_resize
) —— 是否调整图像大小。 - size (
Dict[str, int]
,可选,默认为self.size
)—— 控制在resize
之后图像的大小。将图像的短边调整为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
,可选) — 返回张量的类型。可以是以下之一:- 未设置:返回列表
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
或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
类 transformers.ViltProcessor
< source >( image_processor = None tokenizer = None **kwargs )
参数
- image_processor (
ViltImageProcessor
, 可选) — 一个 ViltImageProcessor 实例。图像处理器是一个必需的输入。 - tokenizer (
BertTokenizerFast
, 可选) — 一个实例。分词器是一个必需的输入。
构建一个将 BERT 分词器和 ViLT 图像处理器包装为单个处理器的 ViLT 处理器。
ViltProcessor 提供了 ViltImageProcessor 和 BertTokenizerFast 的所有功能。请参阅 call() 和 decode()
的文档字符串以获取更多信息。
__call__
< 来源 >( 图像 文本: 取合 = 无添加特殊标记: 布尔型 = True填充: 取合 = False截断: 取合 = 无最大长度: 可选 = 无步长: 整型 = 0填充到倍数: 可选 = 无返回标记类型ID: 可选 = 无返回注意掩码: 可选 = 无返回溢出标记: 布尔型 = False返回特殊标记掩码: 布尔型 = False返回偏移量映射: 布尔型 = False返回长度: 布尔型 = False详细: 布尔型 = True返回张量: 取合 = 无**kwargs )
此方法使用ViltImageProcessor.调用()方法准备图像,并使用BertTokenizerFast.调用()准备模型文本。
请参阅上述两个方法的文档字符串以获取更多信息。
ViltModel
类 transformers.ViltModel
< source >( config add_pooling_layer = True )
参数
- config (ViltConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
一个未经任何特定头部处理的原始隐藏状态的ViLT模型。这是一个PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
子类。将其用作常规PyTorch模块,并请参考PyTorch文档了解所有与一般使用和行为相关的内容。
正向传递
< 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 or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
的形状为({0})
) — 输入序列标记的词汇索引。索引可以通过 AutoTokenizer 获取。详情请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入ID? - attention_mask (
torch.FloatTensor
的形状为({0})
,非必需) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
:- 1 表示 未掩码 的标记,
- 0 表示 掩码 的标记。 什么是注意力掩码?
- token_type_ids (
torch.LongTensor
的形状为({0})
,非必需) — 用于指示输入的第一和第二部分的标记段索引。索引选择在[0, 1]
:- 0 对应于 句子 A 标记,
- 1 对应于 句子 B 标记。 什么是标记类型ID?
- pixel_values(《torch.FloatTensor》形状
(batch_size, num_channels, height, width)
)—像素值。像素值可以通过AutoImageProcessor获取。关于更详细的信息,请参阅ViltImageProcessor.call()。 - pixel_mask(《torch.LongTensor》形状
(batch_size, height, width)
,可选)—避免在填充像素值上执行注意力的掩码。掩码值选择的范围为[0, 1]
:- 1表示像素是真实的(即未掩码),
- 0表示像素是填充的(即掩码)。
什么是注意力掩码? <../glossary.html#attention-mask>
- head_mask(《torch.FloatTensor》形状
(num_heads,)
或(num_layers, num_heads)
,可选)—遮蔽自注意力模块中选定的头。掩码值选择的范围为[0, 1]
:- 1表示头部未被掩码,
- 0表示头部被掩码。
- 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
转换为补丁嵌入时,这种情况很有用。 - 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 (
torch.FloatTensor
的形状为(batch_size, sequence_length, hidden_size)
) — 模型最后层输出处的隐藏状态序列。 -
pooler_output (
torch.FloatTensor
的形状为(batch_size, hidden_size)
) — 通过用于辅助预训练任务的层进一步处理后,序列首令牌(分类令牌)的最后层隐藏状态。例如,对于 BERT-family 模型,这返回在通过一个线性层和一个 tanh 激活函数处理后,分类令牌的结果。线性层的权重在预训练期间从下一个句子预测(分类)目标训练得到。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,在传入output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
的元组(如果模型有嵌入层,则为嵌入输出之后,每个层的输出一个)。在每个层输出处的模型的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,在传入output_attentions=True
或当config.output_attentions=True
时返回) — 实例为shape
(batch_size, num_heads, sequence_length, sequence_length)
的title
的元组(每个层一个)。在注意力softmax之后的注意权重,用于在自注意力头中计算加权平均。
ViltModel的forward方法,覆盖了__call__
特殊方法。
尽管需要在函数内部定义前向传递的配方,但在之后调用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
_子类。将其用作常规PyTorch模块,并查阅PyTorch文档以获取与通用使用和行为有关的所有信息。
正向传递
< 来源 >( 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.MaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
形状(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。索引可以通过 AutoTokenizer 获得。有关详细信息,请见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入ID? - attention_mask (
torch.FloatTensor
形状(batch_size, sequence_length)
, 可选) — 避免在填充标记索引上执行注意力的掩码。所选掩码值在[0, 1]
内:- 1 表示 未掩码 的标记,
- 0 表示 掩码 的标记。《什么是注意力掩码?
- token_type_ids (
torch.LongTensor
形状(batch_size, sequence_length)
, 可选) — 用于指示输入的前后部分的段标记索引。索引在[0, 1]
内选择:- 0 对应于 句子A 标记,
- 1 对应于 句子B 标记。《什么是标记类型ID?
- pixel_values(形状为
(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 ViltImageProcessor.call()。 - pixel_mask(形状为(batch_size, height, width),可选)—— 用于避免在填充像素值上执行注意力的掩码。掩码值选择在
[0, 1]
中:- 1 表示真实的像素(即 非掩码),
- 0 表示填充的像素(即 掩码)。
什么是注意力掩码? <../glossary.html#attention-mask>
- head_mask(形状为
(num_heads,)
或(num_layers, num_heads)
,可选)—— 用于无效化自注意力模块中选定的头的掩码。掩码值选择在[0, 1]
中:- 1 表示頭部 未掩码,
- 0 表示头部 掩码。
- inputs_embeds (
torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选,您可以选择直接传递嵌入表示而不是input_ids
,这在您想对将input_ids
索引转换为相关向量有更多控制权时很有用,比模型内部嵌入查找矩阵更灵活。 - image_embeds (
torch.FloatTensor
of shape(batch_size, num_patches, hidden_size)
, optional) — 可选,您可以选择直接传递嵌入表示而不是pixel_values
,这在您想对将pixel_values
转换为补丁嵌入有更多控制权时很有用。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的张量。有关更多详细信息,请参阅返回张量下的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)
A 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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
的元组(如果模型有嵌入层,则为嵌入输出之后,每个层的输出一个)。在每个层输出处的模型的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,在传入output_attentions=True
或当config.output_attentions=True
时返回) — 实例为shape
(batch_size, num_heads, sequence_length, sequence_length)
的title
的元组(每个层一个)。在注意力softmax之后的注意权重,用于在自注意力头中计算加权平均。
《ViltForMaskedLM》前向方法,重写了`__call__`特殊方法。
尽管需要在函数内部定义前向传递的配方,但在之后调用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
类 transformers.ViltForQuestionAnswering
< source >( config )
参数
- config(《ViltConfig》)— 包含所有模型参数的模型配置类。使用配置文件初始化不会加载模型的相关权重,只加载配置。请查看from_pretrained() 方法来加载模型权重。
视觉问答的Vilt模型变压器,其顶部有一个分类器头部(位于[CLS]标记的最终隐藏状态之上的线性层),例如用于VQAv2。
此模型是PyTorch torch.nn.Module
_子类。将其用作常规PyTorch模块,并查阅PyTorch文档以获取与通用使用和行为有关的所有信息。
正向传递
< 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 (形状为
({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 (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 ViltImageProcessor.call()。 - pixel_mask (
torch.LongTensor
形状为(batch_size, height, width)
,可选) — 避免对填充像素值执行注意的掩码。掩码值介于[0, 1]
之间:- 1 表示真实的像素(即 未掩码),
- 0 表示填充像素(即 掩码)。
注意掩码是什么? <../glossary.html#attention-mask>
- head_mask (
torch.FloatTensor
形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 使自注意模块中选择的头失效的掩码。掩码值介于[0, 1]
之间:- 1 表示头部 未掩码,
- 0 表示头部 掩码。
- 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
转换为补丁嵌入则很有用。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回ModelOutput而不是普通元组。 - labels (
形状为
(batch_size, num_labels)
的torch.FloatTensor
,可选) — 计算视觉问答损失时的标签。此张量必须是批处理中给定示例的所有适用答案的一_hot编码,或者是一个表示哪些答案适用的软编码,其中1.0是最高分。
返回值
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.SequenceClassifierOutput 或一个包含torch.FloatTensor
的元组(如果传递了return_dict=False
或当config.return_dict=False
时),具体取决于配置(ViltConfig)和输入。
-
损失(
torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回)—分类(或如果config.num_labels==1,则为回归)损失。 -
(
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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
的元组(如果模型有嵌入层,则为嵌入输出之后,每个层的输出一个)。在每个层输出处的模型的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,在传入output_attentions=True
或当config.output_attentions=True
时返回) — 实例为shape
(batch_size, num_heads, sequence_length, sequence_length)
的title
的元组(每个层一个)。在注意力softmax之后的注意权重,用于在自注意力头中计算加权平均。
ViltForQuestionAnswering 前向方法覆盖了__call__
特殊方法。
尽管需要在函数内部定义前向传递的配方,但在之后调用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
类 transformers.ViltForImagesAndTextClassification
< 源代码 >( config )
参数
- input_ids(
torch.LongTensor
,形状为({0})
)—输入序列标记的索引,这些索引来自词汇表。索引可以通过AutoTokenizer获得。有关详细信息,请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。 输入ID是什么? - attention_mask (
torch.FloatTensor
的形状({0})
,可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选自[0, 1]
:- 1 用于 未掩码 的标记,
- 0 用于 掩码 的标记。 什么是注意掩码?
- token_type_ids (
torch.LongTensor
的形状({0})
,可选) — 地标标记索引以指示输入的第一和第二部分。索引选自[0, 1]
:- 0 对应于 句子 A 标记,
- 1 对应于 句子 B 标记。 什么是标记类型 ID?
- 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)
,可选) — 避免对填充像素值执行注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示实际的像素(即 未掩码),
- 0 表示填充的像素(即 掩码)。
什么是注意力掩码? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
的形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 使自我注意力模块中选定的头无效的掩码。掩码值在[0, 1]
中选择:- 1 表示头 未掩码,
- 0 表示头 掩码。
- 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
转换为补丁嵌入,这将很有用。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回一个 ModelOutput,而不是一个普通的元组。
Vilt模型,顶部有分类头,用于自然语言视觉推理,例如NLVR2。
正向传递
< source >( input_ids: 可选 = Noneattention_mask: 可选 = Nonetoken_type_ids: 可选 = Nonepixel_values: 可选 = Nonepixel_mask: 可选 = Nonehead_mask: 可选 = Noneinputs_embeds: 可选 = Noneimage_embeds: 可选 = Nonelabels: 可选 = Noneoutput_attentions: 可选 = Noneoutput_hidden_states: 可选 = Nonereturn_dict: 可选 = None ) → transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
of shape({0})
) — 输入序列 token 的索引。索引可以通过使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID? - attention_mask (
torch.FloatTensor
形状为({0})
,可选)—— 避免对填充标记索引执行注意力的掩码。掩码值选择在[0, 1]
:- 1 表示 未屏蔽 的标记,
- 0 表示 屏蔽 的标记。 什么是注意力掩码?
- token_type_ids (
torch.LongTensor
形状为({0})
,可选)—— 标记段索引以指示输入的第一个和第二个部分。索引选择在[0, 1]
:- 0 对应于 句子 A 标记,
- 1 对应于 句子 B 标记。 什么是标记类型 ID?
- pixel_values (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
)—— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息请参阅 ViltImageProcessor.call()。 - pixel_mask (
torch.LongTensor
形状(batch_size, height, width)
, 可选) — 避免在对填充像素值执行注意力时的掩码。掩码值选择在[0, 1]
:- 1 表示真实像素(即 未掩码),
- 0 表示填充像素(即 掩码)。
什么是注意力掩码? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
形状(num_heads,)
或(num_layers, num_heads)
, 可选) — 扫描自注意力模块中选定的头部。掩码值选择在[0, 1]
:- 1 表示头部 未掩码,
- 0 表示头部 掩码。
- 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
转换为补丁嵌入,这非常有用。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回ModelOutput而不是一个普通的元组。 - labels (
torch.LongTensor
,形状为(batch_size,)
,可选) — 二值分类标签。
返回值
transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
或tuple(torch.FloatTensor)
如果传入return_dict=False
或当config.return_dict=False
时,返回ViltConfig)和输入不同,它将包括transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput
或一个torch.FloatTensor
的元组。
- 损失(
torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回)—分类(或如果config.num_labels==1,则为回归)损失。 - (
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
) — 该模型的每个层输出的隐藏状态的元组的列表,形状为(batch_size, sequence_length, hidden_size)
,包括嵌入输出。 - attentions (
List[tuple(torch.FloatTensor)]
,可选,当传入output_attentions=True
时返回或当config.output_attentions=True
) — 包含每对图像和文本的注意力权重的列表,形状为(batch_size, num_heads, sequence_length, sequence_length)
。
ViltForImagesAndTextClassification的前向方法覆盖了特殊的__call__
方法。
尽管需要在函数内部定义前向传递的配方,但在之后调用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 模型转换器,顶部带有一个分类器头(CLS 标志的最终隐藏状态的线性层),用于图像到文本或文本到图像检索,例如 MSCOCO 和 F30K。
此模型是PyTorch torch.nn.Module
_子类。将其用作常规PyTorch模块,并查阅PyTorch文档以获取与通用使用和行为有关的所有信息。
正向传递
< 源代码 >( 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})
) — 输入序列标记的索引。索引可以通过 AutoTokenizer 获取。详情见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入ID? - attention_mask (
torch.FloatTensor
形状({0})
,可选) — 用于防止对填充标记索引执行注意力的掩码。掩码值选择在[0, 1]
之间:- 1 对于未被掩码的标记,
- 0 对于被掩码的标记。 什么是注意力掩码?
- token_type_ids (
torch.LongTensor
尺寸为({0})
,可选) — 用以指示输入的第一个和第二个部分的片段标记索引。索引选择在[0, 1]
:- 0 对应于句子 A标记,
- 1 对应于句子 B标记。什么是标记类型 ID?
- pixel_values (
torch.FloatTensor
尺寸为(batch_size, num_channels, height, width)
) — 像素值。可以使用AutoImageProcessor来获取像素值。请参阅ViltImageProcessor.call()以获取详细信息。 - pixel_mask (
torch.LongTensor
尺寸为(batch_size, height, width)
,可选) — 用于避免对填充像素值执行注意力的掩码。掩码值选取于[0, 1]
:- 1 对于真实像素(即非掩码),
- 0 对于填充像素(即掩码)。
什么是注意力掩码?<../glossary.html#attention-mask>
- head_mask (
torch.FloatTensor
的形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 用于取消自注意力模块中已选定头部的屏蔽掩码。屏蔽值在[0, 1]
内选:- 1 表示该头部 未屏蔽;
- 0 表示该头部 已屏蔽。
- 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
, 可选) — 是否返回所有注意力层的注意力张量。请参见返回张量下的attentions
以获取更多详细信息。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。请参见返回张量下的hidden_states
以获取更多详细信息。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是普通的元组。 - labels(《torch.LongTensor 形状为(batch_size,)的标量,可选)当前不支持标签。
返回值
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.SequenceClassifierOutput 或一个包含torch.FloatTensor
的元组(如果传递了return_dict=False
或当config.return_dict=False
时),具体取决于配置(ViltConfig)和输入。
-
损失(
torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回)—分类(或如果config.num_labels==1,则为回归)损失。 -
(
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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
的元组(如果模型有嵌入层,则为嵌入输出之后,每个层的输出一个)。在每个层输出处的模型的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,在传入output_attentions=True
或当config.output_attentions=True
时返回) — 实例为shape
(batch_size, num_heads, sequence_length, sequence_length)
的title
的元组(每个层一个)。在注意力softmax之后的注意权重,用于在自注意力头中计算加权平均。
《ViltForImageAndTextRetrieval》的前向方法,覆盖了特殊方法 __call__
。
尽管需要在函数内部定义前向传递的配方,但在之后调用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
类 transformers.ViltForTokenClassification
< source >( config )
参数
- config (ViltConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法来加载模型权重。
ViLT 模型,顶部有一个标记分类头(文本标记的最后隐藏状态上的线性层),例如用于命名实体识别(NER)任务。
此模型是PyTorch torch.nn.Module
_子类。将其用作常规PyTorch模块,并查阅PyTorch文档以获取与通用使用和行为有关的所有信息。
正向传递
< 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.TokenClassifierOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
of shape({0})
) — 输入序列标记在词汇表中的索引。可以通过 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID? - 注意力掩码 (
torch.FloatTensor
的形状为({0})
,可选) — 以便避免对填充令牌索引执行注意力操作。掩码值在[0, 1]
之间选择: - token_type_ids (
torch.LongTensor
的形状为({0})
,可选) — 用于指示输入第一部分和第二部分的段令牌索引。索引在[0, 1]
之间选择: - pixel_values (
torch.FloatTensor
的形状为(batch_size, num_channels, height, width)
) — 像素值。使用 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 (
torch.FloatTensor
形状为(batch_size, num_patches, hidden_size)
的向量,可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递pixel_values
。如果你希望更多地控制如何将pixel_values
转换为 patch 嵌入,这将非常有用。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量中的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量中的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 对象而不是普通元组。 - labels (
torch.LongTensor
形状为(batch_size, text_sequence_length)
, 可选) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。
返回值
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.TokenClassifierOutput 或一个包含多种元素的元组,这些元素取决于配置(ViltConfig)和输入,如果传递 return_dict=False
或当 config.return_dict=False
时。
-
loss (
torch.FloatTensor
形状为(1,)
, 可选,在提供labels
时返回) — 分类损失。 -
logits (
torch.FloatTensor
形状为(batch_size, sequence_length, config.num_labels)
) — 分类分数(在 SoftMax 之前)。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,在传入output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
的元组(如果模型有嵌入层,则为嵌入输出之后,每个层的输出一个)。在每个层输出处的模型的隐藏状态,加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,在传入output_attentions=True
或当config.output_attentions=True
时返回) — 实例为shape
(batch_size, num_heads, sequence_length, sequence_length)
的title
的元组(每个层一个)。在注意力softmax之后的注意权重,用于在自注意力头中计算加权平均。
《transformers.ViltForTokenClassification》的 forward 方法覆盖了特殊方法 __call__
。
尽管需要在函数内部定义前向传递的配方,但在之后调用Module
实例而不是这个方法,因为前者负责运行预处理和后处理步骤,而后者则默默忽略它们。