Transformers文档

感知器

Hugging Face's logo
加入Hugging Face社区

并获得增强的文档体验访问权限

开始使用

感知器

概述

Perceiver IO模型由Andrew Jaegle、Sebastian Borgeaud、Jean-Baptiste Alayrac、Carl Doersch、Catalin Ionescu、David Ding、Skanda Koppula、Daniel Zoran、Andrew Brock、Evan Shelhamer、Olivier Hénaff、Matthew M. Botvinick、Andrew Zisserman、Oriol Vinyals、João Carreira在《Perceiver IO:结构化输入和输出的通用架构》中提出,该文发表于arXiv

Perceiver IO是Perceiver的一般化版本,它不仅能处理任意输入,还能处理任意输出。原始的Perceiver只能生成单一的分类标签。除了分类标签,Perceiver IO还可以生成语言、光流和包含音频的多模态视频。这一切都是通过使用与原始Perceiver相同的构建块实现的。Perceiver IO的计算复杂度与输入和输出大小的线性相关,大部分处理都在潜在空间中进行,这使得我们能够处理比标准Transformer能够处理的更大的输入和输出。这意味着,例如,Perceiver IO可以直接使用字节而不是分词输入来做BERT风格的掩码语言模型。

论文的摘要如下

最近提出的Perceiver模型在多个领域(如图像、音频、多模态、点云)上取得了很好的结果,同时在计算和内存的使用上与输入大小呈线性扩展。虽然Perceiver支持许多种输入,但它只能生成非常简单的输出,例如类分数。Perceiver IO克服了这一限制,同时没有放弃原始模型的有吸引力的特性,通过学习灵活地查询模型的多维潜在空间,以产生任意大小和语义的输出。Perceiver IO仍然将模型深度与数据大小分离,并且仍然与数据大小线性扩展,但现在与输入和输出大小都相关。完整的Perceiver IO模型在具有高度结构化输出空间的任务上取得了强大的结果,例如自然语言理解和视觉理解、星际争霸II、多任务和多模态领域。作为亮点,Perceiver IO在GLUE语言基准测试中与基于Transformer的BERT基准相当,而且无需进行输入分词,并在Sintel光流估计上取得了最先进的性能。

以下是对Perceiver工作原理的简短解释

Transformer自注意力机制的优点是时间需求和内存需求与序列长度的平方成正比。因此,BERT和RoBERTa等模型被限制在最大序列长度为512个标记。Perceiver试图通过在输入上不执行自注意力,而是在一组潜在变量上执行它,并仅使用输入进行交叉注意力来解决此问题。这样,时间和内存需求不再取决于输入的长度,因为已经使用了一个固定数量的潜在变量,例如256或512。这些变量是随机初始化的,之后使用反向传播进行端到端的训练。

在内部,PerceiverModel将创建潜在变量,它是一个形状为(batch_size, num_latents, d_latents)的张量。人们必须向模型提供inputs(可以是文本、图像、音频等),然后模型将使用这些输入与潜在变量进行交叉注意力。Perceiver编码器的输出也是一个形状相同的张量。然后人们可以像BERT一样,通过对序列维度进行平均将潜在变量的最后一个隐藏状态转换为分类对数,然后在其上放置一个线性层将d_latents投影到num_labels

这是原始Perceiver论文中的想法。然而,它只能输出分类对数。在后续的工作中,PerceiverIO,他们将这一想法推广到让模型也能生成任意大小的输出。怎么做到的呢?实际上这个想法是相对简单的:定义任意大小的输出,然后应用交叉注意力操作,使用输出作为查询,潜在变量作为键和值。

假设我们要使用Perceiver进行带掩码的语言建模(BERT风格)。由于Perceiver的输入长度不会影响自注意力层的计算时间,可以提供原始字节数据,向模型提供长度为2048的inputs。如果从这个2048个标记中屏蔽掉一些,可以将outputs定义为形状:(batch_size, 2048, 768)。接下来,将潜藏状态的最后隐藏状态与交叉注意力进行操作以更新outputs张量。交叉注意力操作后,我们仍然有一个形状为(batch_size, 2048, 768)的张量。然后在上面放置一个常规的语言建模头,将最后一维投影到模型的词汇量大小,即创建形状为(batch_size, 2048, 262)的 logits(因为Perceiver使用262个字节的ID作为词汇量大小)。

drawing Perceiver IO架构。源自原文

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

由于PyTorch中的错误,Perceiver无法与torch.nn.DataParallel一起使用,请参阅问题#36035

资源

Perceiver特定输出

transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput

< >

( logits: FloatTensor = None last_hidden_state: FloatTensor = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )

参数

  • logits (torch.FloatTensor of shape (batch_size, num_labels)) — 在 SoftMax 之前的分类(或回归,如果 config.num_labels==1)得分。
  • last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一个层的输出处的隐藏状态序列。
  • hidden_statestuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回)— 模型每层输出隐藏状态的 torch.FloatTensor 元组(一个用于嵌入输出,一个用于每层的输出)形状为 (batch_size, sequence_length, hidden_size)。包括每层输出隐藏状态和初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,当传递 output_attentions=Trueconfig.output_attentions=True 时返回)— 每层注意力权重的 torch.FloatTensor 元组,形状为 (batch_size, num_heads, sequence_length, sequence_length)。用于计算自注意力头中的加权平均。
  • cross_attentionstuple(torch.FloatTensor)可选,当传递 output_attentions=Trueconfig.output_attentions=True 时返回)— 变换器交叉注意力层的注意力权重,形状为 (batch_size, num_heads, sequence_length, sequence_length)。在交叉注意力头中用于计算加权平均。

Perceiver基础模型输出的基类,包含潜在的隐藏状态、注意力和交叉注意力。

transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput

< >

( logits: FloatTensor = None cross_attentions: Optional = None )

参数

  • logits (torch.FloatTensor of shape (batch_size, num_labels)) — 基本解码器的输出。
  • cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 解码器跨注意力层交叉注意力权重,在注意力softmax后返回,用于计算跨注意力头的加权平均。

Perceiver解码器输出的基础类,可能包含跨注意力。

class transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput

< >

( loss: 可选 = None logits: FloatTensor = None hidden_states: 可选 = None attentions: 可选 = None cross_attentions: 可选 = None )

参数

  • 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时返回) — 形状为(batch_size, num_heads, num_latents, num_latents)torch.FloatTensor元组(每个层一个)。注意力的权重在注意力softmax之后,用于计算自注意力头中的加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每个层一个)。解码器交叉注意力层的注意力权重,在注意力softmax之后,用于计算交叉注意力头中的加权平均。

Perceiver掩码语言模型输出的基类。

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput

< >

( loss: 可选 = None logits: FloatTensor = None hidden_states: 可选 = None attentions: 可选 = None cross_attentions: 可选 = None )

参数

  • 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后的注意力权重,用于计算自注意力头的加权和。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递output_attentions=True时返回,或者当config.output_attentions=True时返回) — 包含每个层的torch.FloatTensor的元组,形状为 (batch_size, num_heads, sequence_length, sequence_length)。这是解码器交叉注意力层在应用softmax之后的注意力权重,用于计算交叉注意力头的加权和。

序列/图像分类模型、光流和多模态自编码器的Perceiver输出的基类。

PerceiverConfig

transformers.PerceiverConfig

< >

( num_latents = 256 d_latents = 1280 d_model = 768 num_blocks = 1 num_self_attends_per_block = 26 num_self_attention_heads = 8 num_cross_attention_heads = 8 qk_channels = None v_channels = None cross_attention_shape_for_attention = 'kv' self_attention_widening_factor = 1 cross_attention_widening_factor = 1 hidden_act = 'gelu' attention_probs_dropout_prob = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-12 use_query_residual = True vocab_size = 262 max_position_embeddings = 2048 image_size = 56 train_size = [368, 496] num_frames = 16 audio_samples_per_frame = 1920 samples_per_patch = 16 output_shape = [1, 16, 224, 224] output_num_channels = 512 _label_trainable_num_channels = 1024 **kwargs )

参数

  • num_latents (int, 可选, 默认为256) — 潜变量数量。
  • d_latents (int, 可选, 默认为1280) — 潜嵌入维度。
  • d_model (int, 可选, 默认为 768) — 输入的维度。只有在使用[PerceiverTextPreprocessor]或未提供预处理器的情况下才需要提供。
  • num_blocks (int, 可选, 默认为 1) — Transformer 编码器中的块数。
  • num_self_attends_per_block (int, 可选, 默认为 26) — 每个块中的自注意力层的数量。
  • num_self_attention_heads (int, 可选, 默认为8) — Transformer编码器中每个自我注意力层的注意力头数。
  • num_cross_attention_heads (int, 可选, 默认为8) — Transformer编码器中每个交叉注意力层的注意力头数。
  • qk_channels (int, 可选) — 在编码器的交叉注意力和自我注意力层中应用注意力之前,将查询词和键值投影的维度。如果没有指定,将默认保留查询词的维度。
  • 虚拟通道(v_channels) (int, 选项性) — 在编码器的交叉注意力和自注意力层中应用注意力之前,值的投影维度。如果未指定,将默认保留查询维度的维度。
  • 交叉注意力注意力形状(cross_attention_shape_for_attention) (str, 选项性,默认为"kv") — 在编码器交叉注意力层中下采样查询和键的维度。
  • 自注意力扩展因子(self_attention_widening_factor) (int, 选项性,默认为1) — Transformer编码器交叉注意力层中前馈层的维度。
  • cross_attention_widening_factorint,可选,默认为 1)—— Transformer 编码器中自注意力层的前馈层的维度。
  • hidden_actstrfunction,可选,默认为 "gelu")—— 编码器和池器中的非线性激活函数(函数或字符串)。如果是字符串,支持的选项有 "gelu""relu""selu""gelu_new"
  • attention_probs_dropout_probfloat,可选,默认为 0.1)—— 注意力概率的dropout比率。
  • initializer_rangefloat,可选,默认为 0.02)—— 用于初始化所有权重矩阵的截断正态分布初始化器(truncated_normal_initializer)的标准差。
  • layer_norm_eps (float, 可选,默认为1e-12) — 层归一化层使用的epsilon值。
  • use_query_residual (float, 可选,默认为True) — 是否在编码器的交叉注意力层中添加query残差。
  • vocab_size (int, 可选,默认为262) — 遮罩语言模型词汇表的大小。
  • max_position_embeddings (int, 可选,默认为2048) — 遮罩语言模型可能用到的最大序列长度。通常设置为一个较大的值以预防偶然情况(例如,512或1024或2048)。
  • image_size (int, 可选, 默认值为 56) — 预处理后的图像大小,用于 PerceiverForImageClassificationLearned
  • train_size (List[int], 可选, 默认值为 [368, 496]) — 光流模型的图像训练大小。
  • num_frames (int, 可选, 默认值为 16) — 用于多模态自动编码模型的视频帧数。
  • audio_samples_per_frameint,可选项,默认为 1920) — 每帧音频样本的数量,用于多模态自编码模型。
  • samples_per_patchint,可选项,默认为 16) — 在多模态自编码模型中对音频进行预处理时每块音频样本的数量。
  • output_shapeList[int],可选项,默认为 [1, 16, 224, 224]) — 多模态自编码模型视频解码查询的输出形状(batch_size,num_frames,height,width)。这不包括通道维度。
  • output_num_channels(《int》,可选,默认为512)—每个模态解码器的输出通道数。

这是存储Perceiver模型配置的配置类。它用于根据指定的参数实例化Perceiver模型,定义模型架构。使用默认值创建配置将会得到与Perceiver deepmind/language-perceiver架构相似的配置。

配置对象继承自PretrainedConfig,并可以用于控制模型输出。更多关于PretrainedConfig的信息,请参阅PretrainedConfig文档。

示例

>>> from transformers import PerceiverModel, PerceiverConfig

>>> # Initializing a Perceiver deepmind/language-perceiver style configuration
>>> configuration = PerceiverConfig()

>>> # Initializing a model from the deepmind/language-perceiver style configuration
>>> model = PerceiverModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

PerceiverTokenizer

transformers.PerceiverTokenizer

< >

( pad_token = '[PAD]' bos_token = '[BOS]' eos_token = '[EOS]' mask_token = '[MASK]' cls_token = '[CLS]' sep_token = '[SEP]' model_max_length = 2048 **kwargs )

参数

  • pad_token (str, 可选,默认为 "[PAD]") — 用于填充的标记,例如在处理不同长度的序列时。
  • bos_token (str, 可选,默认为 "[BOS]") — BOS标记(在词汇表中保留,但实际上未使用)。
  • eos_token (str, 可选,默认为"[EOS]") — 序列结束标记(在词汇表中预留,但不实际使用)。
  • mask_token (str, 可选,默认为"[MASK]") — 用于掩盖语言模型的MASK标记。
  • cls_token (str, 可选,默认为"[CLS]") — CLS标记(在词汇表中预留,但不实际使用)。
  • sep_token (str, 可选, 默认为 "[SEP]") — 用于将从两个序列构建序列时使用的分隔符令牌。

构造一个Perceiver分词器。Perceiver简单使用UTF-8编码的字节。

该分词器继承自 PreTrainedTokenizer,其中包含大多数主要方法。用户应参照这个超类以了解更多有关这些方法的信息。

__call__

< >

( text: 合并 = None text_pair: 合并 = None text_target: 合并 = None text_pair_target: 合并 = None add_special_tokens: 布尔 = True padding: 合并 = False truncation: 合并 = None max_length: 可选 = None stride: int = 0 is_split_into_words: 布尔 = False pad_to_multiple_of: 可选 = None return_tensors: 合并 = None return_token_type_ids: 可选 = None return_attention_mask: 可选 = None return_overflowing_tokens: 布尔 = False return_special_tokens_mask: 布尔 = False return_offsets_mapping: 布尔 = False return_length: 布尔 = False verbose: 布尔 = True **kwargs ) BatchEncoding

参数

  • text (str, List[str], List[List[str]], 可选) — 要编码的序列或序列批。每个序列可以是字符串,也可以是字符串列表(预分词字符串)。如果提供的序列是字符串列表(预分词),则必须设置 is_split_into_words=True(以便消除与批次的歧义)。
  • text_pair (str, List[str], List[List[str]], 可选) — 要编码的序列或序列批。每个序列可以是字符串,也可以是字符串列表(预分词字符串)。如果提供的序列是字符串列表(预分词),则必须设置 is_split_into_words=True(以便消除与批次的歧义)。
  • text_target (str, List[str], List[List[str]], 可选) — 要编码为目标文本的序列或序列批。每个序列可以是字符串,也可以是字符串列表(预分词字符串)。如果提供的序列是字符串列表(预分词),则必须设置 is_split_into_words=True(以便消除与批次的歧义)。
  • text_pair_targetstrList[str]List[List[str]],可选项)—— 要编码为目标文本的序列或序列批次。每个序列可以是一个字符串或字符串列表(预先分词字符串)。如果序列作为字符串列表(预先分词)提供,必须设置is_split_into_words=True(以消除与序列批次的歧义)。
  • add_special_tokensbool,可选项,默认为True)—— 编码序列时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数,该函数定义了哪些标记将自动添加到输入ID。如果您想自动添加boseos标记,这将非常有用。
  • padding (bool, strPaddingStrategy可选,默认为 False) — 激活并控制填充。接受以下值:

    • True'longest':填充到批次中最长的序列(如果没有提供单个序列,则不填充)。
    • 'max_length':填充到由参数 max_length 指定或如果没有提供该参数,则为模型可接受的最大输入长度。
    • False'do_not_pad'(默认):不填充(即,可以输出具有不同长度的序列的批次)。
  • truncation (bool, strTruncationStrategy可选,默认为 False) — 激活并控制截断。接受以下值:

    • True'longest_first':截断到由参数 max_length 指定的最大长度或如果没有提供该参数,则为模型可接受的最大输入长度。这将按顺序截断标记,如果提供了成对的序列(或一对序列的批次),则会从最长的序列中移除标记。
    • 'only_first':截断到由参数 max_length 指定的最大长度或如果没有提供该参数,则为模型可接受的最大输入长度。如果提供了成对的序列(或一对序列的批次),则只截断第一个序列。
    • 'only_second':截断到由参数 max_length 指定的最大长度或如果没有提供该参数,则为模型可接受的最大输入长度。如果提供了成对的序列(或一对序列的批次),则只截断第二个序列。
    • False'do_not_truncate'(默认):不截断(即,可以输出序列长度大于模型最大允许输入大小的批次)。
  • max_length (int, 可选) — 控制使用由其中一个截断/填充参数指定的最大长度。

    如果未设置或设置为 None,在需要截断/填充参数的最大长度时将使用预定义的模型最大长度。如果模型没有特定的最大输入长度(如XLNet),则将禁用截断/填充到最大长度。

  • stride (int, 可选,默认为 0) — 如果设置为数字并连同 max_length 一起使用,当 return_overflowing_tokens=True 时返回的超额令牌将包含一些截断序列末尾的令牌,以在截断序列和超额序列之间提供一些重叠。该参数的值定义了重叠令牌的数量。
  • is_split_into_words (bool, 可选,默认为 false) — 是否输入已被预分词(例如,按单词分割)。如果设置为 true,分词器假设输入已按单词分割(例如,通过在空白处分割)并将其分词。这对于命名实体识别或令牌分类很有用。
  • pad_to_multiple_of (int, 可选) — 如果设置为 true,将序列填充到提供值的倍数。需要激活 padding。这对于在配备 CUDA 7.5 版本(Volta)的 NVIDIA 硬件上使用 Tensor Cores 特别有用。
  • return_tensors (strTensorType, 可选) — 如果设置为 true,将返回 tensor 而不是 Python 整数的列表。可接受值包括:
  • return_token_type_ids (bool, 可选) — 是否返回 token 类型 ID。如果设置为默认值,将根据特定 tokenizer 的默认值返回 token 类型 ID,由 return_outputs 属性定义。
  • return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果保留为默认值,将根据具体分词器的默认设置返回注意力掩码,该设置由 return_outputs 属性定义。

    什么是注意力掩码?

  • return_overflowing_tokens (bool, 可选,默认为 False) — 是否返回溢出的标记序列。当输入的是关于输入 ID 的序列对(或批次),且 truncation_strategy = longest_firstTrue 时,将引发错误而不是返回溢出的标记。
  • return_special_tokens_mask (bool, 可选,默认为 False) — 是否返回特殊标记掩码信息。
  • return_offsets_mapping (bool, 可选, 默认为 False) — 是否返回每个标记的 (char_start, char_end)
  • return_length (bool, 可选, 默认为 False) — 是否返回编码输入的长度。
  • verbose (bool, 可选, 默认为 True) — 是否打印更多信息和警告。

返回值

BatchEncoding

一个包含以下字段的 BatchEncoding

  • input_ids — 被送入模型的标记 ID 列表。

    什么是输入 ID?

  • token_type_ids — 被送入模型的标记类型 ID 列表(当 return_token_type_ids=True“token_type_ids”self.model_input_names 中时)。

    什么是标记类型 ID?

  • attention_mask — 指定模型应关注哪些标记的索引列表(当 return_attention_mask=True“attention_mask”self.model_input_names 中时)。

    什么是注意力掩码?

  • overflowing_tokens — 流出标记序列列表(当指定了 max_length 并设置 return_overflowing_tokens=True 时)。

  • num_truncated_tokens — 被截断的标记数量(当指定了 max_lengthreturn_overflowing_tokens=True 时)。

  • special_tokens_mask — 包含 0 和 1 的列表,其中 1 表示添加了特殊标记,0 表示普通序列标记(当 add_special_tokens=Truereturn_special_tokens_mask=True 时)。

  • length — 输入长度(当 return_length=True 时)

主要方法,用于对一系列序列或一对序列进行标记和准备模型。

PerceiverFeatureExtractor

class transformers.PerceiverFeatureExtractor

< >

( *args **kwargs )

__call__

< >

( images **kwargs )

对图像或图像批进行处理。

PerceiverImageProcessor

transformers.PerceiverImageProcessor

< >

( do_center_crop: bool = True crop_size: Dict = None do_resize: bool = True size: Dict = None 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 **kwargs )

参数

  • do_center_crop (bool, optional, 默认 True) — 是否实现图像居中裁剪。如果输入尺寸在任何一条边小于 crop_size,图像将被零填充然后居中裁剪。可以被 preprocess 方法中的 do_center_crop 参数覆盖。
  • crop_size (Dict[str, int], optional, 默认 {"height": 256, "width": 256}) - 应用居中裁剪时期望的输出大小。可以被 preprocess 方法中的 crop_size 参数覆盖。
  • do_resize (bool, optional, 默认 True) — 是否将图像调整大小到 (size["height"], size["width"])。可以被 preprocess 方法中的 do_resize 参数覆盖。
  • 大小 (Dict[str, int] 可选,默认为 {"height" -- 224, "width": 224}):调整图像大小后的尺寸。可以通过 preprocess 方法中的 size 参数来覆盖。
  • 重采样 (PILImageResampling可选,默认为 PILImageResampling.BICUBIC) —— 定义调整图像大小时使用的重采样滤波器。可以通过 preprocess 方法中的 resample 参数来覆盖。
  • 是否重放缩 (bool可选,默认为 True) —— 是否通过指定的缩放因子 rescale_factor 重放缩图像。可以通过 preprocess 方法中的 do_rescale 参数来覆盖。
  • rescale_factorintfloat,可选,默认值为 1/255) — 定义用于图像缩放的比例因子。可以由 preprocess 方法中的 rescale_factor 参数覆盖。do_normalize — 是否标准化图像。可以由 preprocess 方法中的 do_normalize 参数覆盖。
  • image_meanfloatList[float],可选,默认值为 IMAGENET_STANDARD_MEAN) — 如果对图像进行标准化,则使用的均值。这是一个浮点数或长度与图像通道数相等的浮点数列表。可以由 preprocess 方法中的 image_mean 参数覆盖。
  • image_stdfloatList[float],可选,默认值为 IMAGENET_STANDARD_STD) — 如果对图像进行标准化,则使用的标准差。这是一个浮点数或长度与图像通道数相等的浮点数列表。可以由 preprocess 方法中的 image_std 参数覆盖。

构建Perceiver图像处理器。

preprocess

< >

( images: Union do_center_crop: Optional = None crop_size: Optional = None do_resize: Optional = None size: 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 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_center_crop (bool, 可选,默认为 self.do_center_crop ) — 是否将图像居中裁剪到 crop_size
  • crop_size (Dict[str, int], 可选,默认为 self.crop_size ) — 居中裁剪后期望的输出大小。
  • do_resize (bool, 可选,默认为 self.do_resize ) — 是否调整图像大小。
  • size (Dict[str, int], 可选,默认为 self.size ) — 调整大小后图像的大小。
  • resampleint可选,默认为self.resample)— 如果要调整图像大小,则使用的重采样过滤器。这可以是枚举类型PILImageResampling之一。只有当do_resize设置为True时才有作用。
  • do_rescalebool可选,默认为self.do_rescale)— 是否要进行图像缩放。
  • rescale_factorfloat可选,默认为self.rescale_factor)— 当do_rescale设置为True时,按此比例因子进行图像缩放。
  • do_normalizebool,可选,默认 self.do_normalize)— 是否标准化图像。
  • image_meanfloatList[float],可选,默认 self.image_mean)— 图像均值。
  • image_stdfloatList[float],可选,默认 self.image_std)— 图像标准差。

预处理图像或图像批次。

PerceiverTextPreprocessor

transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor

< >

( config: PerceiverConfig )

参数

Perceiver编码器的文本预处理。可用于将inputs嵌入并添加位置编码。

嵌入维度由配置的d_model属性确定。

PerceiverImagePreprocessor

transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor

< >

( config prep_type = 'conv' spatial_downsample: int = 4 temporal_downsample: int = 1 position_encoding_type: str = 'fourier' in_channels: int = 3 out_channels: int = 64 conv_after_patching: bool = False conv_after_patching_in_channels: int = 54 conv2d_use_batchnorm: bool = True concat_or_add_pos: str = 'concat' project_pos_dim: int = -1 **position_encoding_kwargs )

参数

  • config ([PerceiverConfig]) — 模型配置。
  • prep_type (str, 可选, 默认为 "conv") — 预处理类型。可以是“conv1x1”、“conv”、“patches”、“pixels”。
  • spatial_downsample (int, 可选, 默认为4) — 空间降采样因子。
  • temporal_downsample (int, 可选, 默认为1) — 时间降采样因子(仅在存在时间维度时相关)。
  • position_encoding_type (str, 可选, 默认为"fourier") — 位置编码类型。可以是“fourier”或“trainable”。
  • in_channels (int, 可选, 默认为3) — 输入通道数。
  • out_channels(《int》,可选,默认为64)— 输出中的通道数。
  • conv_after_patching(《bool》,可选,默认为False)— 是否在补丁处理后应用卷积层。
  • conv_after_patching_in_channels(《int》,可选,默认为54)— 补丁后卷积层的输入通道数。
  • conv2d_use_batchnorm(《bool》,可选,默认为True)— 是否在卷积层中使用批归一化。
  • concat_or_add_pos (str, 可选,默认为"concat") — 如何将位置编码连接到输入。可以是“concat”或“add”。
  • project_pos_dim (int, 可选,默认为-1) — 位置编码投影的维度。如果为-1,则不应用投影。
  • *position_encoding_kwargs (Dict, 可选) — 位置编码的关键字参数。

Perceiver 编码器的图像预处理。

注意:如果将prep_type设置为“conv1x1”或“conv”,则out_channels参数指的是卷积层的输出通道数。如果添加绝对位置嵌入,必须确保位置编码kwargs的num_channels设置为与out_channels相等。

PerceiverOneHotPreprocessor

transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor

< >

( config: PerceiverConfig )

参数

Perceiver编码器的one-hot预处理器。可以用于向输入添加虚拟索引维度。

PerceiverAudioPreprocessor

transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor

< >

( config prep_type: str = 'patches' samples_per_patch: int = 96 position_encoding_type: str = 'fourier' concat_or_add_pos: str = 'concat' out_channels = 64 project_pos_dim = -1 **position_encoding_kwargs )

参数

  • config ([PerceiverConfig]) — 模型配置。
  • prep_type (str,可选,默认为"patches") — 要使用的预处理类型。只支持“patches”。
  • samples_per_patch(《int》, 可选, 默认为96) — 每个补丁的样本数。
  • position_encoding_type(《str》, 可选, 默认为"fourier") — 使用位置编码的类型。可以是 "trainable" 或 "fourier"。
  • concat_or_add_pos (str, 可选,默认为 "concat") — 如何连接位置编码到输入。可以是 “concat” 或 “add”。
  • out_channels (int, 可选,默认为 64) — 输出的通道数。
  • project_pos_dim (int, 可选,默认为 -1) — 将位置编码投影到的维度。如果为 -1,则不应用投影。
  • **position_encoding_kwargs (Dict, optional) — 位置编码的关键字参数。

Perceiver编码器的音频预处理。

PerceiverMultimodalPreprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor

< >

( modalities: Mapping mask_probs: Optional = None min_padding_size: int = 2 )

参数

  • modalities (Mapping[str, PreprocessorType]) — 将模态名称映射到预处理器 的字典。
  • mask_probs (Dict[str, float]) — 将模态名称映射到该模态掩码概率的字典。
  • min_padding_size (int, 可选, 默认为 2) — 所有模态的最小填充大小。最终输出将具有与所有模态中最大通道数相等的 num_channels,并加上 min_padding_size。

Perceiver编码器的多模态预处理。

每个模态的输入先进行预处理,然后使用可训练的位置嵌入进行填充,以获得相同数量的通道数。

PerceiverProjectionDecoder

transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder

< >

( config )

参数

基线投影解码器(无交叉注意力)。

PerceiverBasicDecoder

transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder

< >

( config: 接收器配置 output_num_channels: int position_encoding_type: 可选 = 'trainable' output_index_dims: 可选 = None num_channels: 可选 = 128 subsampled_index_dims: 可选 = None qk_channels: 可选 = None v_channels: 可选 = None num_heads: 可选 = 1 widening_factor: 可选 = 1 use_query_residual: 可选 = False concat_preprocessed_input: 可选 = False final_project: 可选 = True position_encoding_only: 可选 = False **position_encoding_kwargs )

参数

  • config ([接收器配置]) — 模型配置。
  • output_num_channels (int, 可选) — 输出通道的数量。只有在 final_project 被设置为 True 时才会使用。
  • position_encoding_type (str, 可选,默认为 "trainable") — 要使用的位置编码的类型。可以是 "trainable","fourier" 或 "none"。
  • output_index_dims (int, 可选) — 输出查询的维度数。如果 'position_encoding_type' == 'none',则会被忽略。
  • num_channels (int, 可选, 默认为128) — 解码器查询的通道数。如果 'position_encoding_type' == 'none',则忽略此参数。
  • qk_channels (int, 可选) — 交叉注意力层中查询和键的通道数。
  • v_channels (int, 可选) — 交叉注意力层中值的通道数。
  • num_heads (int, 可选, 默认为1) — 交叉注意力层中的注意力头数量。
  • widening_factor (int, 可选, 默认为1) — 交叉注意力层的扩展因子。
  • use_query_residual (bool, 可选, 默认为 False) — 是否在查询与交叉注意力层的输出之间使用残差连接。
  • concat_preprocessed_input (布尔值, 可选,默认为 False) — 是否将预处理的输入连接到查询。
  • final_project (布尔值, 可选,默认为 True) — 是否将交叉注意力层的输出投影到目标维度。
  • position_encoding_only (布尔值, 可选,默认为 False) — 是否仅使用此类定义输出查询。

基于交叉注意力的解码器。此类可用于使用交叉注意力操作解码潜在状态的最后隐藏状态,其中潜在状态产生键和值。

此类的输出形状取决于如何定义输出查询(也称为解码器查询)。

PerceiverClassificationDecoder

transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder

< >

( config **decoder_kwargs )

参数

基于交叉注意力的分类解码器。对logit输出的轻量级包裹器 PerceiverBasicDecoder。将形状为 (batch_size, num_latents, d_latents) 的Perceiver编码器输出转换为形状为 (batch_size, num_labels) 的张量。查询的形状为 (batch_size, 1, num_labels)。

PerceiverOpticalFlowDecoder

transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder

< >

( config output_image_shape output_num_channels = 2 rescale_factor = 100.0 **decoder_kwargs )

基于交叉注意力机制的光流解码器。

PerceiverBasicVideoAutoencodingDecoder

transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder

< >

( config: PerceiverConfig output_shape: List position_encoding_type: str **decoder_kwargs )

参数

  • config ([PerceiverConfig]) — 模型配置。
  • output_shape (List[int]) — 输出的形状为 (batch_size, num_frames, height, width),不包括通道维度。
  • position_encoding_type (str) — 使用的位置编码类型。可以是“trainable”(可训练)、“fourier”(傅里叶型)或“none”(无)。

基于交叉注意力机制的视频自编码解码器。对PerceiverBasicDecoder的轻量级封装,并包含视频重塑逻辑。

PerceiverMultimodalDecoder

transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder

< >

参数

  • output_num_channels (int) — 输出的通道数量。
  • min_padding_size (int, 可选, 默认值 2) — 所有模态的最小填充大小。最终输出将具有等于所有模态的最大通道数加上 min_padding_size 的 num_channels。
  • subsampled_index_dims (Dict[str, PerceiverAbstractDecoder], 可选) — 将模态名称映射到用于该模态解码器查询的降采样索引维度的字典。

由单模态解码器组成的多模态解码。构造函数的 modalities 参数是映射模态名称到该模态解码器的字典。该解码器将用于构建该模态的查询。在将模态特定的查询用可训练的模态特定参数填充后,它们沿着时间维度进行拼接。

接下来是一个共享的跨所有模态的交叉注意力操作。

PerceiverProjectionPostprocessor

transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor

< >

( in_channels: int out_channels: int )

参数

  • in_channels (int) — 输入通道数。
  • out_channels (int) — 输出通道数。

Perceiver的投影后处理。可用于将解码器输出的通道投影到更低维度。

PerceiverAudioPostprocessor

transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor

< >

( config: PerceiverConfig in_channels: int postproc_type: str = 'patches' )

参数

  • config ([PerceiverConfig]) — 模型配置。
  • in_channels (int) — 输入通道数。
  • postproc_type (str, 可选, 默认值为 "patches") —要使用的后处理类型。目前只支持“patches”。

Perceiver的音频后处理。可用于将解码器的输出转换为音频特征。

PerceiverClassificationPostprocessor

transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor

< >

config: PerceiverConfig in_channels: int

参数

  • config ([PerceiverConfig]) — 模型配置。
  • in_channels (int) — 输入通道数量。

Perceiver的分类后处理。可以将解码器输出转换为分类对数。

PerceiverMultimodalPostprocessor

transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor

< >

( modalities: Mapping input_is_dict: bool = False )

参数

  • modalities (Mapping[str, PostprocessorType]) — 将模态名称映射到该模态后处理类的小字典。
  • input_is_dict (布尔值,可选,默认为 False)— 如果为 True,则假定输入为字典结构,并且输出保持与相同的字典形状。如果为 False,则输入是张量,在后处理期间通过 modality_sizes 切片。

Perceiver 的多模态后处理。可用于将特定模态的后处理器组合到一个单一的后处理器中。

PerceiverModel

transformers.PerceiverModel

< >

( config decoder = None input_preprocessor: Callable = None output_postprocessor: Callable = None )

参数

  • config (PerceiverConfig) — 包含所有模型参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。请查看from_pretrained()方法来加载模型权重。
  • decoder (DecoderType, optional) — 可选的解码器,用于解码编码器的潜在表示。示例包括transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecodertransformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecodertransformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder
  • input_preprocessor (PreprocessorType, optional) — 可选的输入预处理程序。示例包括transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessortransformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessortransformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessortransformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor
  • output_postprocessor (PostprocessorType, 可选) — 可选的输出后处理器。示例包括:transformers.models.perceiver.modeling_perceiver.PerceiverImagePostprocessortransformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessortransformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessortransformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessortransformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor
  • 注意 您可以定义自己的解码器、预处理器以及/或后处理器以适应您的用例。 —

Perceiver:一种可伸缩的、全注意力架构。

注意,可以将Perceiver在比其训练图像更高的分辨率上进行微调,通过在模型的正向传播中将interpolate_pos_encoding设置为True。这将插值预训练过的位置嵌入到更高分辨率。

该模型是PyTorch torch.nn.Module 的子类。将其用作常规PyTorch模块,并参考PyTorch文档以了解所有与通用使用和行为相关的问题。

正向传播

< >

( inputs: FloatTensor attention_mask: 可选 = None subsampled_output_points: 可选 = None head_mask: 可选 = None output_attentions: 可选 = None output-hidden_states: 可选 = None interpolate_pos_encoding: bool = False return_dict: 可选 = None ) transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput or tuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — 输入到感知器。可以是任何东西:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length)可选) — 避免在对填充标记索引执行注意力时的掩码。掩码值在 [0, 1] 中选择:

    • 1 对于 未掩码 的标记,
    • 0 对于 掩码 的标记。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor 表示形状为 (num_heads,)(num_layers, num_heads) 的矩阵,可选) — 用于取消自注意力模块中选中头部的掩码。掩码值在 [0, 1] 范围内:

    • 1 表示头部未被掩码,
    • 0 表示头部被掩码。
  • output_attentions (bool,可选) — 是否返回所有注意力层的注意力张量。有关更多详情,请参阅返回张量下的 attentions
  • output_hidden_states (bool,可选) — 是否返回所有层的隐藏状态。有关更多详情,请参阅返回张量下的 hidden_states
  • interpolate_pos_encodingbool可选,默认为False)— 是否插值预训练的位置编码。
  • return_dictbool可选)— 是否返回一个 ModelOutput 而不是普通的元组。

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverModelOutputtuple(torch.FloatTensor)

transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput 或一个包含torch.FloatTensor的元组(如果return_dict=False被传递或当config.return_dict=False)根据配置(PerceiverConfig)和输入的不同元素。

  • logits (形状为(batch_size, num_labels)torch.FloatTensor)— 分类的分数(如果config.num_labels==1则为回归)(在SoftMax之前)。
  • last_hidden_state (形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor)— 模型最后一层的隐藏状态序列。
  • hidden_statestuple(torch.FloatTensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True)— 一个torch.FloatTensor的元组(一个用于嵌入输出的输出 + 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)。模型每一层的隐藏状态以及在每层的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,在传递output_attentions=True时返回或当config.output_attentions=True)— 一个torch.FloatTensor的元组(用于每一层)形状为(batch_size, num_heads, sequence_length, sequence_length)。注意softmax后的注意力权重,用于在自注意力头部计算加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递参数 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重,在注意力softmax后使用,用于在交叉注意力头中计算加权平均。

PerceiverModel 的 forward 方法覆盖了 __call__ 特殊方法。

尽管需要在这个函数内部定义前向传递的配方,但应该之后调用 Module 实例而不是这个,因为前者负责运行预和后处理步骤,而后者默默地忽略了它们。

示例

>>> from transformers import PerceiverConfig, PerceiverTokenizer, PerceiverImageProcessor, PerceiverModel
>>> from transformers.models.perceiver.modeling_perceiver import (
...     PerceiverTextPreprocessor,
...     PerceiverImagePreprocessor,
...     PerceiverClassificationDecoder,
... )
>>> import torch
>>> import requests
>>> from PIL import Image

>>> # EXAMPLE 1: using the Perceiver to classify texts
>>> # - we define a TextPreprocessor, which can be used to embed tokens
>>> # - we define a ClassificationDecoder, which can be used to decode the
>>> # final hidden states of the latents to classification logits
>>> # using trainable position embeddings
>>> config = PerceiverConfig()
>>> preprocessor = PerceiverTextPreprocessor(config)
>>> decoder = PerceiverClassificationDecoder(
...     config,
...     num_channels=config.d_latents,
...     trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
...     use_query_residual=True,
... )
>>> model = PerceiverModel(config, input_preprocessor=preprocessor, decoder=decoder)

>>> # you can then do a forward pass as follows:
>>> tokenizer = PerceiverTokenizer()
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids

>>> with torch.no_grad():
...     outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]

>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()

>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)

>>> # EXAMPLE 2: using the Perceiver to classify images
>>> # - we define an ImagePreprocessor, which can be used to embed images
>>> config = PerceiverConfig(image_size=224)
>>> preprocessor = PerceiverImagePreprocessor(
...     config,
...     prep_type="conv1x1",
...     spatial_downsample=1,
...     out_channels=256,
...     position_encoding_type="trainable",
...     concat_or_add_pos="concat",
...     project_pos_dim=256,
...     trainable_position_encoding_kwargs=dict(
...         num_channels=256,
...         index_dims=config.image_size**2,
...     ),
... )

>>> model = PerceiverModel(
...     config,
...     input_preprocessor=preprocessor,
...     decoder=PerceiverClassificationDecoder(
...         config,
...         num_channels=config.d_latents,
...         trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
...         use_query_residual=True,
...     ),
... )

>>> # you can then do a forward pass as follows:
>>> image_processor = PerceiverImageProcessor()
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(image, return_tensors="pt").pixel_values

>>> with torch.no_grad():
...     outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]

>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()

>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)

PerceiverForMaskedLM

class transformers.PerceiverForMaskedLM

< >

( config: PerceiverConfig )

参数

  • config (PerceiverConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载模型相关的权重,只加载配置。请查看from_pretrained()方法来加载模型权重。

Perceiver在掩码语言建模中的示例用法。这是一个PyTorch torch.nn.Module的子类。将其作为常规PyTorch模块使用,并参考PyTorch文档以了解所有与通用使用和行为相关的内容。

正向传播

< >

( inputs: 可选 = None attention_mask: 可选 = None head_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None labels: 可选 = None return_dict: 可选 = None input_ids: 可选 = None ) transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutputtuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — Perceiver的输入。可以是任何东西:图片、文本、音频、视频等。
  • attention_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) — 避免在填充令牌索引上执行注意力的掩码。掩码值选择在 [0, 1] 之间:

    • 1表示未掩码的令牌,
    • 0表示掩码的令牌。

    什么是注意掩码?

  • head_mask (形状为 torch.FloatTensor(num_heads,)(num_layers, num_heads)可选)— 用于取消自我注意力模块选择头部的掩码。掩码中的选择值在 [0, 1] 范围内:

    • 1 表示头部 未掩码
    • 0 表示头部 已掩码
  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多信息,请参阅返回的张量下的 attentions
  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多信息,请参阅返回的张量下的 hidden_states
  • interpolate_pos_encoding(《bool》,可选,默认为 False)—— 是否插值预训练的位置编码。
  • return_dict(《bool》,可选)—— 是否返回 ModelOutput 而不是普通元组。
  • labels(《torch.LongTensor”,形状为 (batch_size, sequence_length)可选)——用于计算掩码语言模型损失的标签。索引应在 [-100, 0, ..., config.vocab_size](参见 input_ids 文档字符串)中。索引设置为 -100 的令牌将被忽略(掩码),只计算索引在 [0, ..., config.vocab_size] 范围内的令牌的损失。

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutputtuple(torch.FloatTensor)

transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput 或一个由 torch.FloatTensor 组成的元组(如果传递了 return_dict=Falseconfig.return_dict=False),其包含各种元素,具体取决于配置(PerceiverConfig)和输入。

  • loss(《torch.FloatTensor”形状为 (1,)可选,当提供 labels 时返回)——掩码语言模型(MLM)损失。
  • logits(《torch.FloatTensor”,形状为 (batch_size, sequence_length, config.vocab_size))——语言建模头部的预测分数(在 SoftMax 之前每个词汇表的令牌的分数)。
  • hidden_statestuple(torch.FloatTensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True)— 一个torch.FloatTensor的元组(一个用于嵌入输出的输出 + 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)。模型每一层的隐藏状态以及在每层的初始嵌入输出。
  • 注意事项 (tuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回) — 由每个层的torch.FloatTensor组成的元组(每个层一个),形状为(batch_size, num_heads, num_latents, num_latents)。注意,是 attention softmax 之后的权重,用于在自注意力头中计算加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递参数 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重,在注意力softmax后使用,用于在交叉注意力头中计算加权平均。

PerceiverForMaskedLM 的前进方法覆盖了特殊方法 __call__

尽管需要在这个函数内部定义前向传递的配方,但应该之后调用 Module 实例而不是这个,因为前者负责运行预和后处理步骤,而后者默默地忽略了它们。

示例

>>> from transformers import AutoTokenizer, PerceiverForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForMaskedLM.from_pretrained("deepmind/language-perceiver")

>>> # training
>>> text = "This is an incomplete sentence where some words are missing."
>>> inputs = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask " missing."
>>> inputs["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> labels = tokenizer(text, padding="max_length", return_tensors="pt").input_ids

>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
19.87

>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]

>>> # inference
>>> text = "This is an incomplete sentence where some words are missing."
>>> encoding = tokenizer(text, padding="max_length", return_tensors="pt")

>>> # mask bytes corresponding to " missing.". Note that the model performs much better if the masked span starts with a space.
>>> encoding["input_ids"][0, 52:61] = tokenizer.mask_token_id

>>> # forward pass
>>> with torch.no_grad():
...     outputs = model(**encoding)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]

>>> masked_tokens_predictions = logits[0, 52:61].argmax(dim=-1).tolist()
>>> tokenizer.decode(masked_tokens_predictions)
' missing.'

PerceiverForSequenceClassification

transformers.PerceiverForSequenceClassification

< >

( config )

参数

  • config (PerceiverConfig) — 模型配置类,包含所有模型参数。使用配置文件初始化时不加载与模型相关的权重,只加载配置。请查看 from_pretrained() 方法来加载模型权重。

示例说明使用Perceiver进行文本分类。这是一个PyTorch的{PyTorch的torch.nn.Module子类。将其作为常规PyTorch模块使用,有关通用使用和行为的所有内容请参阅PyTorch文档。

正向传播

< >

( inputs: Optional = None attention_mask: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None input_ids: Optional = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput or tuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — Perceiver的输入。可以是任何东西:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor 形状为 batch_size, sequence_length可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选中在 [0, 1]

    • 1 表示未 掩码 的标记,
    • 0 表示 已掩码 的标记。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使选定的自注意力模块的头无效的掩码。掩码值选中在 [0, 1]

    • 1 表示头 未掩码
    • 0 表示头 已掩码
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关返回张量 attentions 的更多详细信息,请参阅。
  • labels (torch.LongTensor 形状为 (batch_size,)可选) — 用于计算分类/回归损失的标签。索引应位于 [0, ..., config.num_labels - 1] 内。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵损失)。

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput,或者一个tuple,包含 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False)根据配置(PerceiverConfig)和输入确定的各种元素。

  • losstorch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 分类(或当 config.num_labels==1 时的回归)损失。
  • logitstorch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(或当 config.num_labels==1 时的回归)得分(SoftMax 之前)。
  • hidden_statestuple(torch.FloatTensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True)— 一个torch.FloatTensor的元组(一个用于嵌入输出的输出 + 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)。模型每一层的隐藏状态以及在每层的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,在传递output_attentions=True时返回或当config.output_attentions=True)— 一个torch.FloatTensor的元组(用于每一层)形状为(batch_size, num_heads, sequence_length, sequence_length)。注意softmax后的注意力权重,用于在自注意力头部计算加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递参数 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重,在注意力softmax后使用,用于在交叉注意力头中计算加权平均。

PerceiverForSequenceClassification 前向方法,重写了 __call__ 特殊方法。

尽管需要在这个函数内部定义前向传递的配方,但应该之后调用 Module 实例而不是这个,因为前者负责运行预和后处理步骤,而后者默默地忽略了它们。

示例

>>> from transformers import AutoTokenizer, PerceiverForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForSequenceClassification.from_pretrained("deepmind/language-perceiver")

>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]

PerceiverForImageClassificationLearned

transformers.PerceiverForImageClassificationLearned

< >

( config )

参数

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

Perceiver在图像分类方面的应用示例,适用于ImageNet等任务。

此模型使用学习到的位置嵌入。换句话说,此模型未提供有关图像结构的任何优先信息。如图所示,此模型在ImageNet上达到了72.7%的top-1准确率。

PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor (使用 prep_type="conv1x1") 预处理输入图像,并使用 PerceiverClassificationDecoder 解码 PerceiverModel 的潜在表示,将其转换为分类logits。

该模型是PyTorch torch.nn.Module 的子类。将其用作常规PyTorch模块,并参考PyTorch文档以了解所有与通用使用和行为相关的问题。

正向传播

< >

( inputs: 可选 = None attention_mask: 可选 = None head_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None labels: 可选 = None interpolate_pos_encoding: bool = False return_dict: 可选 = None pixel_values: 可选 = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — 传入到感知器中的输入。可以是任何东西:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor,形状为batch_size, sequence_length可选) — 避免在填充标记索引上执行注意力的遮罩。遮罩值选择在[0, 1]之间:

    • 1 表示 未遮罩 的标记;
    • 0 表示 遮罩 的标记。

    什么是注意力遮罩?

  • head_mask (torch.FloatTensor 形状 (num_heads,)(num_layers, num_heads)可选。) — 用于取消选择自注意力模块中选择的头部的掩码。在 [0, 1] 中选择的掩码值:

    • 1 表示头部 未被掩码
    • 0 表示头部 被掩码
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更详细的信息,请参阅返回张量中的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更详细的信息,请参阅返回张量中的 hidden_states
  • interpolate_pos_encoding (bool, 可选, 默认为 False) — 是否插值预训练的位置编码。
  • return_dict (bool, 可选) — 是否返回一个ModelOutput而不是普通的元组
  • labels (torch.LongTensor 的形状为 (batch_size,), 可选) —— 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1,计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵损失)。

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput,或者一个tuple,包含 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False)根据配置(PerceiverConfig)和输入确定的各种元素。

  • losstorch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 分类(或当 config.num_labels==1 时的回归)损失。
  • logitstorch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(或当 config.num_labels==1 时的回归)得分(SoftMax 之前)。
  • hidden_statestuple(torch.FloatTensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True)— 一个torch.FloatTensor的元组(一个用于嵌入输出的输出 + 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)。模型每一层的隐藏状态以及在每层的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,在传递output_attentions=True时返回或当config.output_attentions=True)— 一个torch.FloatTensor的元组(用于每一层)形状为(batch_size, num_heads, sequence_length, sequence_length)。注意softmax后的注意力权重,用于在自注意力头部计算加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递参数 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重,在注意力softmax后使用,用于在交叉注意力头中计算加权平均。

PerceiverForImageClassificationLearned 的前进方法重写了 __call__ 特殊方法。

尽管需要在这个函数内部定义前向传递的配方,但应该之后调用 Module 实例而不是这个,因为前者负责运行预和后处理步骤,而后者默默地忽略了它们。

示例

>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationLearned
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-learned")
>>> model = PerceiverForImageClassificationLearned.from_pretrained("deepmind/vision-perceiver-learned")

>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby cat

PerceiverForImageClassificationFourier

transformers.PerceiverForImageClassificationFourier

< >

( config )

参数

  • config (PerceiverConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不加载模型相关的权重,只加载配置。请查看 from_pretrained() 方法以加载模型权重。

Perceiver在图像分类方面的应用示例,适用于ImageNet等任务。

该模型使用固定的二维傅里叶位置嵌入。如图中所示,该模型在ImageNet上的准确率为79.0(top-1),在大规模数据集(即JFT)上预训练后的准确率为84.5。

PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor(带有 prep_type="pixels")预处理输入图像,并使用 PerceiverClassificationDecoder 解码 PerceiverModel 的潜在表示为分类对数。

该模型是PyTorch torch.nn.Module 的子类。将其用作常规PyTorch模块,并参考PyTorch文档以了解所有与通用使用和行为相关的问题。

正向传播

< >

( inputs: 可选 None attention_mask: 可选 None head_mask: 可选 None output_attentions: 可选 None output_hidden_states: 可选 None labels: 可选 None return_dict: 可选 None pixel_values: 可选 None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — 输入给Perceiver。可以是任何东西:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) — 用于防止在填充词索引上执行注意力的遮罩。遮罩值选择在 [0, 1] 内:

    • 1 代表 未遮罩 的token,
    • 0 代表 遮罩 的token。

    什么是注意遮罩?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择头部失效的遮罩。遮罩值选择在 [0, 1] 内:

    • 1 表示头部 未遮罩,
    • 0 表示头部 遮罩
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多信息,请参见返回张量下的 hidden_states
  • interpolate_pos_encoding (bool, 可选,默认为 False) — 是否插值预训练的位置编码。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。
  • labels (torch.LongTensor of shape (batch_size,), optional) — 计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput,或者一个tuple,包含 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False)根据配置(PerceiverConfig)和输入确定的各种元素。

  • losstorch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 分类(或当 config.num_labels==1 时的回归)损失。
  • logitstorch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(或当 config.num_labels==1 时的回归)得分(SoftMax 之前)。
  • hidden_statestuple(torch.FloatTensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True)— 一个torch.FloatTensor的元组(一个用于嵌入输出的输出 + 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)。模型每一层的隐藏状态以及在每层的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,在传递output_attentions=True时返回或当config.output_attentions=True)— 一个torch.FloatTensor的元组(用于每一层)形状为(batch_size, num_heads, sequence_length, sequence_length)。注意softmax后的注意力权重,用于在自注意力头部计算加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递参数 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重,在注意力softmax后使用,用于在交叉注意力头中计算加权平均。

PerceiverForImageClassificationFourier 的前向方法,覆盖了 __call__ 特殊方法。

尽管需要在这个函数内部定义前向传递的配方,但应该之后调用 Module 实例而不是这个,因为前者负责运行预和后处理步骤,而后者默默地忽略了它们。

示例

>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationFourier
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-fourier")
>>> model = PerceiverForImageClassificationFourier.from_pretrained("deepmind/vision-perceiver-fourier")

>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby cat

PerceiverForImageClassificationConvProcessing

transformers.PerceiverForImageClassificationConvProcessing

< >

( config )

参数

  • config (PerceiverConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只有配置。请查看 from_pretrained() 方法以加载模型权重。

Perceiver在图像分类方面的应用示例,适用于ImageNet等任务。

此模型使用2D卷积+最大池化预处理网络。根据论文所示,此模型在ImageNet上可达到82.1%的top-1准确率。

PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor (带 prep_type="conv") 预处理输入图像,并使用 PerceiverClassificationDecoderPerceiverModel 的潜在表示解码为分类logits。

该模型是PyTorch torch.nn.Module 的子类。将其用作常规PyTorch模块,并参考PyTorch文档以了解所有与通用使用和行为相关的问题。

正向传播

< >

( inputs: 可选 None attention_mask: 可选 None head_mask: 可选 None output_attentions: 可选 None output_hidden_states: 可选 None labels: 可选 None return_dict: 可选 None pixel_values: 可选 None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — 传入perceiver的输入。可以是任何类型:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor,形状为 batch_size, sequence_length,可选项) — 避免在填充token索引上执行注意力的掩码。掩码值选择在 [0, 1]

    • 1 代表未掩码的token,
    • 0 代表被掩码的token。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads),可选项) — 禁用电解质子模块中选定头部的掩码。掩码值选择在 [0, 1]

    • 1 表示头部未掩码,
    • 0 表示头部被掩码。
  • output_attentions (bool,可选项) — 是否返回所有注意力层的注意力张量。有关更多信息,请参阅返回的张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的 hidden_states
  • interpolate_pos_encoding (bool, 可选, 默认为 False) — 是否插值预先训练的定位编码。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是空元组。
  • labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput,或者一个tuple,包含 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False)根据配置(PerceiverConfig)和输入确定的各种元素。

  • losstorch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 分类(或当 config.num_labels==1 时的回归)损失。
  • logitstorch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(或当 config.num_labels==1 时的回归)得分(SoftMax 之前)。
  • hidden_statestuple(torch.FloatTensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True)— 一个torch.FloatTensor的元组(一个用于嵌入输出的输出 + 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)。模型每一层的隐藏状态以及在每层的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,在传递output_attentions=True时返回或当config.output_attentions=True)— 一个torch.FloatTensor的元组(用于每一层)形状为(batch_size, num_heads, sequence_length, sequence_length)。注意softmax后的注意力权重,用于在自注意力头部计算加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递参数 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重,在注意力softmax后使用,用于在交叉注意力头中计算加权平均。

《PerceiverForImageClassificationConvProcessing》的 forward 方法,重写了 __call__ 特殊方法。

尽管需要在这个函数内部定义前向传递的配方,但应该之后调用 Module 实例而不是这个,因为前者负责运行预和后处理步骤,而后者默默地忽略了它们。

示例

>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationConvProcessing
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-conv")
>>> model = PerceiverForImageClassificationConvProcessing.from_pretrained("deepmind/vision-perceiver-conv")

>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby cat

PerceiverForOpticalFlow

transformers.PerceiverForOpticalFlow

< >

( config )

参数

  • config (PerceiverConfig) — 包含模型所有参数的模型配置类。用配置文件初始化时不会加载数据集与模型关联的权重,只有配置。请查看 from_pretrained() 方法以加载模型权重。

Perceiver在光流任务(如Sintel和KITTI)中的示例用法。PerceiverForOpticalFlow 使用 PerceiverImagePreprocessor(带 prep_type="patches")对输入图像进行预处理,并使用 PerceiverOpticalFlowDecoder 来解码 PerceiverModel 的潜在表示。

作为输入,沿通道维度连接两个连续帧,并在每个像素周围提取一个3 x 3的块(为每个像素生成3 x 3 x 3 x 2 = 54个值)。使用固定傅里叶位置编码对块中每个像素的位置进行编码。接下来,应用Perceiver编码器。为了解码,使用与输入相同的编码查询潜在表示。

该模型是PyTorch torch.nn.Module 的子类。将其用作常规PyTorch模块,并参考PyTorch文档以了解所有与通用使用和行为相关的问题。

正向传播

< >

( inputs: 可选 = None attention_mask: 可选 = None head_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None labels: 可选 = None return_dict: 可选 = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput or tuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — 传入感知器。可以是任何东西:图像、文本、音频、视频等。
  • attention_mask (形状为 batch_size, sequence_lengthtorch.FloatTensor可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]
    • 1 表示 未掩码 的标记,
    • 0 表示 掩码 的标记。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选)—— 用于屏蔽自注意力模块中选定的头的掩码。掩码值在 [0, 1] 之间选择:

    • 1 表示头未屏蔽,
    • 0 表示头已屏蔽。
  • output_attentions (bool可选)—— 是否返回所有注意力的张量。更多详细信息请参阅返回的张量下的 attentions
  • output_hidden_states (bool可选)—— 是否返回所有层的隐藏状态。更多详细信息请参阅返回的张量下的 hidden_states
  • interpolate_pos_encoding (bool, 可选, 默认为 False) — 是否进行预训练位置编码的插值。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是普通的元组。
  • labels (torch.LongTensor 形状 (batch_size,), 可选) — 用于计算光流损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput,或者一个tuple,包含 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False)根据配置(PerceiverConfig)和输入确定的各种元素。

  • losstorch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 分类(或当 config.num_labels==1 时的回归)损失。
  • logitstorch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(或当 config.num_labels==1 时的回归)得分(SoftMax 之前)。
  • hidden_statestuple(torch.FloatTensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True)— 一个torch.FloatTensor的元组(一个用于嵌入输出的输出 + 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)。模型每一层的隐藏状态以及在每层的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,在传递output_attentions=True时返回或当config.output_attentions=True)— 一个torch.FloatTensor的元组(用于每一层)形状为(batch_size, num_heads, sequence_length, sequence_length)。注意softmax后的注意力权重,用于在自注意力头部计算加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递参数 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重,在注意力softmax后使用,用于在交叉注意力头中计算加权平均。

PerceiverForOpticalFlow forward 方法覆盖了 __call__ 特殊方法。

尽管需要在这个函数内部定义前向传递的配方,但应该之后调用 Module 实例而不是这个,因为前者负责运行预和后处理步骤,而后者默默地忽略了它们。

示例

>>> from transformers import PerceiverForOpticalFlow
>>> import torch

>>> model = PerceiverForOpticalFlow.from_pretrained("deepmind/optical-flow-perceiver")

>>> # in the Perceiver IO paper, the authors extract a 3 x 3 patch around each pixel,
>>> # leading to 3 x 3 x 3 = 27 values for each pixel (as each pixel also has 3 color channels)
>>> # patches have shape (batch_size, num_frames, num_channels, height, width)
>>> # the authors train on resolutions of 368 x 496
>>> patches = torch.randn(1, 2, 27, 368, 496)
>>> outputs = model(inputs=patches)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 368, 496, 2]

PerceiverForMultimodalAutoencoding

transformers.PerceiverForMultimodalAutoencoding

< >

( config: PerceiverConfig )

参数

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

Perceiver在多模态(视频)自动编码中的应用示例,例如在Kinetics-700任务中。

PerceiverForMultimodalAutoencoding使用PerceiverMultimodalPreprocessor对图像、音频和类别标签的三个模态进行预处理。这个预处理程序使用特定于模态的预处理程序分别对每个模态进行预处理,之后将它们连接。然后,使用可训练的位置嵌入来填充每个模态以具有相同数量的通道,以便在时间维度上进行连接。接下来,应用Perceiver编码器。

PerceiverMultimodalDecoder 用来解码 PerceiverModel 的潜在外表示。该解码器利用每个特定模态的解码器来构建查询。解码器查询是在预处理输入后创建的。然而,在单个前向传递中将整个视频进行自动编码在计算上是不可行的,因此仅使用解码器查询的一部分与潜在外表示进行跨注意力操作。这由每个模态的子采样索引决定,这些索引可以作为额外输入提供给 PerceiverForMultimodalAutoencoding 的前向传递。

PerceiverMultimodalDecoder 还将不同模态的解码器查询填充到相同数量的通道,以便在时间维度上连接它们。然后,与 PerceiverModel 的潜在外表示执行跨注意力。

最后,使用 ~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor 将这个张量转换成实际的视频。它首先将输出分解为不同的模态,然后为每个模态应用相应的后处理器。

请注意,在评估期间通过屏蔽分类标签(即对于“标签”模态简单地提供一个全零张量),此自编码模型成为 Kinetics 700 视频分类器。

该模型是PyTorch torch.nn.Module 的子类。将其用作常规PyTorch模块,并参考PyTorch文档以了解所有与通用使用和行为相关的问题。

正向传播

< >

( inputs: Optional = None attention_mask: Optional = None subsampled_output_points: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput or tuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — Perceiver的输入。可以是任何内容:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 之间:

    • 1 代表未掩码的标记
    • 0 代表已掩码的标记

    什么是注意力掩码?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 隐藏自注意模块中选定头部的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示未掩码的头
    • 0 表示已掩码的头
  • output_attentions (bool, 可选的) —— 是否返回所有注意力层的注意力张量。请参阅返回张量下的 attentions 以获取更多详细信息。
  • output_hidden_states (bool, 可选的) —— 是否返回所有层的隐藏状态。请参阅返回张量下的 hidden_states 以获取更多详细信息。
  • interpolate_pos_encoding (bool, 可选的, 默认为 False) —— 是否插值预训练的位置编码。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是普通的元组。
  • labels (torch.LongTensor 形状为 (batch_size,), 可选) — 用来计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1,则计算一个回归损失(均方损失),如果 config.num_labels > 1,则计算一个分类损失(交叉熵)。

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput,或者一个tuple,包含 torch.FloatTensor (如果传递了 return_dict=False 或当 config.return_dict=False)根据配置(PerceiverConfig)和输入确定的各种元素。

  • losstorch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 分类(或当 config.num_labels==1 时的回归)损失。
  • logitstorch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(或当 config.num_labels==1 时的回归)得分(SoftMax 之前)。
  • hidden_statestuple(torch.FloatTensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True)— 一个torch.FloatTensor的元组(一个用于嵌入输出的输出 + 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)。模型每一层的隐藏状态以及在每层的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,在传递output_attentions=True时返回或当config.output_attentions=True)— 一个torch.FloatTensor的元组(用于每一层)形状为(batch_size, num_heads, sequence_length, sequence_length)。注意softmax后的注意力权重,用于在自注意力头部计算加权平均。
  • cross_attentions (tuple(torch.FloatTensor), 可选,当传递参数 output_attentions=True 或当 config.output_attentions=True 时返回) — 一个 torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重,在注意力softmax后使用,用于在交叉注意力头中计算加权平均。

PerceiverForMultimodalAutoencoding 的 forward 方法,重写了 __call__ 特殊方法。

尽管需要在这个函数内部定义前向传递的配方,但应该之后调用 Module 实例而不是这个,因为前者负责运行预和后处理步骤,而后者默默地忽略了它们。

示例

>>> from transformers import PerceiverForMultimodalAutoencoding
>>> import torch
>>> import numpy as np

>>> # create multimodal inputs
>>> images = torch.randn((1, 16, 3, 224, 224))
>>> audio = torch.randn((1, 30720, 1))
>>> inputs = dict(image=images, audio=audio, label=torch.zeros((images.shape[0], 700)))

>>> model = PerceiverForMultimodalAutoencoding.from_pretrained("deepmind/multimodal-perceiver")

>>> # in the Perceiver IO paper, videos are auto-encoded in chunks
>>> # each chunk subsamples different index dimensions of the image and audio modality decoder queries
>>> nchunks = 128
>>> image_chunk_size = np.prod((16, 224, 224)) // nchunks
>>> audio_chunk_size = audio.shape[1] // model.config.samples_per_patch // nchunks
>>> # process the first chunk
>>> chunk_idx = 0
>>> subsampling = {
...     "image": torch.arange(image_chunk_size * chunk_idx, image_chunk_size * (chunk_idx + 1)),
...     "audio": torch.arange(audio_chunk_size * chunk_idx, audio_chunk_size * (chunk_idx + 1)),
...     "label": None,
... }

>>> outputs = model(inputs=inputs, subsampled_output_points=subsampling)
>>> logits = outputs.logits
>>> list(logits["audio"].shape)
[1, 240]

>>> list(logits["image"].shape)
[1, 6272, 3]

>>> list(logits["label"].shape)
[1, 700]
< > 在 GitHub 上更新