Transformers 文档

Perceiver

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Perceiver

PyTorch

概述

Perceiver IO 模型在 Perceiver IO: A General Architecture for Structured Inputs & Outputs 中提出,作者为 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 是 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 工作原理的 TLDR

Transformer 的自注意力机制的主要问题是,时间和内存需求与序列长度呈二次方关系。因此,像 BERT 和 RoBERTa 这样的模型被限制为最大序列长度 512 个 tokens。Perceiver 旨在通过不对输入执行自注意力,而是对一组潜在变量执行自注意力,并且仅将输入用于交叉注意力来解决此问题。这样,时间和内存需求不再取决于输入的长度,因为人们使用固定数量的潜在变量,例如 256 或 512。这些变量是随机初始化的,之后使用反向传播进行端到端训练。

在内部,PerceiverModel 将创建潜在变量,这是一个形状为 (batch_size, num_latents, d_latents) 的张量。必须向模型提供 inputs(可以是文本、图像、音频,任何你想得到的!),模型将使用它与潜在变量执行交叉注意力。Perceiver 编码器的输出是相同形状的张量。然后,与 BERT 类似,可以通过沿序列维度平均潜在变量的最后隐藏状态,并在其之上放置一个线性层,将 d_latents 投影到 num_labels,从而将潜在变量的最后隐藏状态转换为分类 logits。

这是最初的 Perceiver 论文的想法。但是,它只能输出分类 logits。在后续工作 PerceiverIO 中,他们对其进行了概括,使模型还可以生成任意大小的输出。您可能会问,如何实现?这个想法实际上相对简单:定义任意大小的输出,然后使用潜在变量的最后隐藏状态应用交叉注意力,使用输出作为查询,潜在变量作为键和值。

因此,假设有人想使用 Perceiver 执行掩码语言建模(BERT 风格)。由于 Perceiver 的输入长度不会影响自注意力层的计算时间,因此可以提供原始字节,为模型提供长度为 2048 的 inputs。如果现在掩盖掉这些 2048 个 tokens 中的某些 tokens,则可以将 outputs 定义为形状:(batch_size, 2048, 768)。接下来,使用潜在变量的最终隐藏状态执行交叉注意力以更新 outputs 张量。在交叉注意力之后,仍然有一个形状为 (batch_size, 2048, 768) 的张量。然后可以在其之上放置一个常规的语言建模头,以将最后一个维度投影到模型的词汇表大小,即创建形状为 (batch_size, 2048, 262) 的 logits(因为 Perceiver 使用 262 字节 ID 的词汇表大小)。

drawing Perceiver IO 架构。摘自 原始论文

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

由于 PyTorch 中的一个 bug,Perceiver 适用于 torch.nn.DataParallel,请参阅 issue #36035

资源

Perceiver 特定输出

class transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput

< >

( logits: FloatTensor = None last_hidden_state: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None )

参数

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

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

class transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput

< >

( logits: FloatTensor = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None )

参数

  • logits (形状为 (batch_size, num_labels)torch.FloatTensor) — 基本解码器的输出。
  • cross_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

Perceiver 解码器输出的基类,具有潜在的交叉注意力。

class transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = 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=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(embeddings 的输出一个 + 每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, num_latents, num_latents)。自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。
  • cross_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

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

class transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None )

参数

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

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

PerceiverConfig

class 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) — Latents 的数量。
  • d_latents (int, 可选, 默认为 1280) — 潜在 embeddings 的维度。
  • d_model (int, 可选, 默认为 768) — 输入的维度。 仅在使用了 [PerceiverTextPreprocessor] 或未提供预处理器的情况下才应提供。
  • num_blocks (int, 可选, 默认为 1) — Transformer 编码器中的块数。
  • num_self_attends_per_block (int, 可选, 默认为 26) — 每个块的自注意力层数。
  • num_self_attention_heads (int, optional, defaults to 8) — Transformer 编码器中每个自注意力层的注意力头的数量。
  • num_cross_attention_heads (int, optional, defaults to 8) — Transformer 编码器中每个交叉注意力层的注意力头的数量。
  • qk_channels (int, optional) — 在编码器的交叉注意力和自注意力层中应用注意力之前,用于投影 queries + keys 的维度。如果未指定,则默认为保留 queries 的维度。
  • v_channels (int, optional) — 在编码器的交叉注意力和自注意力层中应用注意力之前,用于投影 values 的维度。如果未指定,则默认为保留 queries 的维度。
  • cross_attention_shape_for_attention (str, optional, defaults to "kv") — 在编码器的交叉注意力层中下采样 queries 和 keys 时使用的维度。
  • self_attention_widening_factor (int, optional, defaults to 1) — Transformer 编码器的交叉注意力层中前馈层的维度。
  • cross_attention_widening_factor (int, optional, defaults to 1) — Transformer 编码器的自注意力层中前馈层的维度。
  • hidden_act (strfunction, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,则支持 "gelu", "relu", "selu""gelu_new"
  • attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。
  • layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon 值。
  • use_query_residual (float, optional, defaults to True) — 是否在编码器的交叉注意力层中添加 query 残差。
  • vocab_size (int, optional, defaults to 262) — masked language modeling 模型的词汇表大小。
  • max_position_embeddings (int, optional, defaults to 2048) — masked language modeling 模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。
  • image_size (int, optional, defaults to 56) — 预处理后图像的大小,用于 PerceiverForImageClassificationLearned
  • train_size (List[int], optional, defaults to [368, 496]) — 光流模型的图像训练尺寸。
  • num_frames (int, optional, defaults to 16) — 用于多模态自编码模型的视频帧数。
  • audio_samples_per_frame (int, optional, defaults to 1920) — 多模态自编码模型的每帧音频样本数。
  • samples_per_patch (int, optional, defaults to 16) — 预处理多模态自编码模型的音频时,每个 patch 的音频样本数。
  • output_shape (List[int], optional, defaults to [1, 16, 224, 224]) — 多模态自编码模型的视频解码器 queries 的输出形状(batch_size, num_frames, height, width)。这不包括通道维度。
  • output_num_channels (int, optional, defaults to 512) — 每个模态解码器的输出通道数。

这是用于存储 PerceiverModel 配置的配置类。它用于根据指定的参数实例化 Perceiver 模型,定义模型架构。使用默认值实例化配置将产生类似于 Perceiver deepmind/language-perceiver 架构的配置。

配置对象继承自 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

class 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, optional, defaults to "[PAD]") — 用于填充的 token,例如在对不同长度的序列进行批处理时。
  • bos_token (str, optional, defaults to "[BOS]") — BOS token(在词汇表中保留,但实际上未使用)。
  • eos_token (str, optional, defaults to "[EOS]") — 序列结束 token(在词汇表中保留,但实际上未使用)。

    当使用特殊 token 构建序列时,这不是用于序列结尾的 token。使用的 token 是 sep_token

  • mask_token (str, optional, defaults to "[MASK]") — MASK token,用于 masked language modeling。
  • cls_token (str, optional, defaults to "[CLS]") — CLS token(在词汇表中保留,但实际上未使用)。
  • sep_token (str, 可选, 默认为 "[SEP]") — 分隔符令牌,用于从两个序列构建一个序列时。

构建 Perceiver 分词器。Perceiver 简单地使用原始字节 utf-8 编码。

此分词器继承自 PreTrainedTokenizer,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

__call__

< >

( text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None text_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **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_target (str, List[str], List[List[str]], 可选) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表(预分词字符串)。如果序列以字符串列表(预分词)形式提供,则必须设置 is_split_into_words=True (以消除与序列批次的歧义)。
  • add_special_tokens (bool, 可选, 默认为 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,则分词器假定输入已拆分为单词(例如,通过在空格上拆分),它将对其进行分词。这对于 NER 或令牌分类很有用。
  • pad_to_multiple_of (int, 可选) — 如果设置,将把序列填充为所提供值的倍数。需要激活 padding。这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上启用 Tensor Core 的使用尤其有用。
  • padding_side (str, 可选) — 模型应在其上应用填充的一侧。应在 [‘right’, ‘left’] 之间选择。默认值从同名的类属性中选取。
  • return_tensors (strTensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:

    • 'tf':返回 TensorFlow tf.constant 对象。
    • 'pt':返回 PyTorch torch.Tensor 对象。
    • 'np':返回 Numpy np.ndarray 对象。
  • return_token_type_ids (bool, 可选) — 是否返回令牌类型 ID。如果保留为默认值,将根据特定分词器的默认值(由 return_outputs 属性定义)返回令牌类型 ID。

    什么是令牌类型 ID?

  • 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)

    这仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用,如果使用 Python 的分词器,此方法将引发 NotImplementedError

  • return_length (bool, 可选, 默认为 False) — 是否返回编码输入的长度。
  • verbose (bool, 可选, 默认为 True) — 是否打印更多信息和警告。
  • **kwargs — 传递给 self.tokenize() 方法

返回:

BatchEncoding

一个 BatchEncoding,包含以下字段:

  • input_ids — 输入模型的 token id 列表。

    什么是输入 ID?

  • token_type_ids — 输入模型的 token 类型 id 列表(当 return_token_type_ids=True 或如果 “token_type_ids”self.model_input_names 中时)。

    什么是 token 类型 ID?

  • attention_mask — 指定模型应注意哪些 token 的索引列表(当 return_attention_mask=True 或如果 “attention_mask”self.model_input_names 中时)。

    什么是 attention mask?

  • overflowing_tokens — 溢出 token 序列的列表(当指定了 max_length 并且 return_overflowing_tokens=True 时)。

  • num_truncated_tokens — 截断的 token 数量(当指定了 max_length 并且 return_overflowing_tokens=True 时)。

  • special_tokens_mask — 由 0 和 1 组成的列表,其中 1 指定添加的特殊 token,0 指定常规序列 token(当 add_special_tokens=True 并且 return_special_tokens_mask=True 时)。

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

用于为一个或多个序列或一个或多个序列对进行 tokenization 和模型准备的主要方法。

PerceiverFeatureExtractor

class transformers.PerceiverFeatureExtractor

< >

( *args **kwargs )

__call__

< >

( images **kwargs )

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

PerceiverImageProcessor

class transformers.PerceiverImageProcessor

< >

( do_center_crop: bool = True crop_size: typing.Dict[str, int] = None do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None **kwargs )

参数

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

构建 Perceiver 图像处理器。

preprocess

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_center_crop: typing.Optional[bool] = None crop_size: typing.Optional[typing.Dict[str, int]] = None do_resize: typing.Optional[bool] = None size: typing.Optional[typing.Dict[str, int]] = None resample: Resampling = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )

参数

  • images (ImageInput) — 要预处理的图像。接受单张或批量的图像,像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间,请设置 do_rescale=False
  • do_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) — 调整大小后图像的尺寸。
  • resample (int, 可选, 默认为 self.resample) — 如果调整图像大小,要使用的重采样过滤器。这可以是枚举 PILImageResampling 中的一个,仅当 do_resize 设置为 True 时才有效。
  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否重新缩放图像。
  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True,则使用此重缩放因子来重缩放图像。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否标准化图像。
  • image_mean (floatList[float], 可选, 默认为 self.image_mean) — 图像均值。
  • image_std (floatList[float], 可选, 默认为 self.image_std) — 图像标准差。
  • return_tensors (strTensorType, 可选) — 返回的张量类型。可以是以下之一:
    • 未设置:返回 np.ndarray 列表。
    • TensorType.TENSORFLOW'tf':返回 tf.Tensor 类型的批次。
    • TensorType.PYTORCH'pt':返回 torch.Tensor 类型的批次。
    • TensorType.NUMPY'np':返回 np.ndarray 类型的批次。
    • TensorType.JAX'jax':返回 jax.numpy.ndarray 类型的批次。
  • data_format (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • ChannelDimension.FIRST:(num_channels, height, width) 格式的图像。
    • ChannelDimension.LAST:(height, width, num_channels) 格式的图像。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,则通道维度格式从输入图像推断。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:(num_channels, height, width) 格式的图像。
    • "channels_last"ChannelDimension.LAST:(height, width, num_channels) 格式的图像。
    • "none"ChannelDimension.NONE:(height, width) 格式的图像。

预处理图像或一批图像。

PerceiverTextPreprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor

< >

( config: PerceiverConfig )

参数

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

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

PerceiverImagePreprocessor

class 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) — 是否在patching后应用卷积层。
  • conv_after_patching_in_channels (int, 可选, 默认为 54) — patching之后卷积层输入中的通道数。
  • conv2d_use_batchnorm (bool, 可选, 默认为 True) — 是否在卷积层中使用批归一化。
  • concat_or_add_pos (str, 可选, 默认为 "concat") — 如何将位置编码连接到输入。可以是 “concat” 或 “add”。
  • project_pos_dim (int, 可选, 默认为 -1) — 要投影到的位置编码的维度。如果为 -1,则不应用投影。
  • **position_encoding_kwargs (Dict, 可选) — 位置编码的关键字参数。

Perceiver 编码器的图像预处理。

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

PerceiverOneHotPreprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor

< >

( config: PerceiverConfig )

参数

One-hot preprocessor for Perceiver Encoder. Can be used to add a dummy index dimension to the input.

PerceiverAudioPreprocessor

class 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, optional, defaults to "patches") — 要使用的预处理器类型。仅支持 “patches”。
  • samples_per_patch (int, optional, defaults to 96) — 每个补丁的样本数。
  • position_encoding_type (str, optional, defaults to "fourier") — 要使用的位置编码类型。可以是 “trainable” 或 “fourier”。
  • concat_or_add_pos (str, optional, defaults to "concat") — 如何将位置编码连接到输入。可以是 “concat” 或 “add”。
  • out_channels (int, optional, defaults to 64) — 输出中的通道数。
  • project_pos_dim (int, optional, defaults to -1) — 要投影到的位置编码的维度。如果为 -1,则不应用投影。
  • **position_encoding_kwargs (Dict, optional) — 位置编码的关键字参数。

Audio preprocessing for Perceiver Encoder.

PerceiverAudioPreprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor

< >

( modalities: typing.Mapping[str, typing.Callable[..., typing.Tuple[torch.Tensor, typing.Optional[torch.Tensor], torch.Tensor]]] mask_probs: typing.Optional[typing.Mapping[str, float]] = None min_padding_size: int = 2 )

参数

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

Multimodal preprocessing for Perceiver Encoder.

Inputs for each modality are preprocessed, then padded with trainable position embeddings to have the same number of channels.

PerceiverProjectionDecoder

class transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder

< >

( config )

参数

Baseline projection decoder (no cross-attention).

PerceiverBasicDecoder

class transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder

< >

( config: PerceiverConfig output_num_channels: int position_encoding_type: typing.Optional[str] = 'trainable' output_index_dims: typing.Optional[int] = None num_channels: typing.Optional[int] = 128 subsampled_index_dims: typing.Optional[int] = None qk_channels: typing.Optional[int] = None v_channels: typing.Optional[int] = None num_heads: typing.Optional[int] = 1 widening_factor: typing.Optional[int] = 1 use_query_residual: typing.Optional[bool] = False concat_preprocessed_input: typing.Optional[bool] = False final_project: typing.Optional[bool] = True position_encoding_only: typing.Optional[bool] = False **position_encoding_kwargs )

参数

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

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

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

PerceiverClassificationDecoder

class transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder

< >

( config **decoder_kwargs )

参数

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

PerceiverOpticalFlowDecoder

class transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder

< >

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

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

PerceiverBasicVideoAutoencodingDecoder

class transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder

< >

( config: PerceiverConfig output_shape: typing.List[int] 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

class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder

< >

( config: PerceiverConfig modalities: typing.Dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder] num_outputs: int output_num_channels: int min_padding_size: typing.Optional[int] = 2 subsampled_index_dims: typing.Optional[typing.Dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder]] = None **decoder_kwargs )

参数

  • config ([PerceiverConfig]) — 模型配置。
  • modalities (Dict[str, PerceiverAbstractDecoder]) — 字典,将模态名称映射到该模态的解码器。
  • num_outputs (int) — 解码器的输出数量。
  • output_num_channels (int) — 输出中的通道数量。
  • min_padding_size (int, optional, defaults to 2) — 所有模态的最小填充尺寸。最终输出的通道数将等于所有模态中最大通道数加上 min_padding_size。
  • subsampled_index_dims (Dict[str, PerceiverAbstractDecoder], optional) — 字典,将模态名称映射到用于该模态解码器查询的子采样索引维度。

通过组合单模态解码器进行多模态解码。构造函数的 modalities 参数是一个字典,将模态名称映射到该模态的解码器。该解码器将用于构建该模态的查询。模态特定的查询会用可训练的模态特定参数进行填充,之后它们会沿着时间维度连接起来。

接下来,所有模态之间会有一个共享的交叉注意力操作。

PerceiverProjectionPostprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor

< >

( in_channels: int out_channels: int )

参数

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

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

PerceiverAudioPostprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor

< >

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

参数

  • config ([PerceiverConfig]) — 模型配置。
  • in_channels (int) — 输入通道的数量。
  • postproc_type (str, optional, defaults to "patches") — 要使用的后处理器类型。目前,仅支持 “patches”。

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

PerceiverClassificationPostprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor

< >

( config: PerceiverConfig in_channels: int )

参数

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

Perceiver 的分类后处理。可用于将解码器输出转换为分类 logits。

PerceiverMultimodalPostprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor

< >

( modalities: typing.Mapping[str, typing.Callable[..., typing.Any]] input_is_dict: bool = False )

参数

  • modalities (Mapping[str, PostprocessorType]) — 字典,将模态名称映射到该模态的后处理器类。
  • input_is_dict (bool, optional, defaults to False) — 如果为 True,则假定输入是字典结构,并且输出保持相同的字典形状。如果为 False,则输入是一个张量,在后处理过程中,会通过 modality_sizes 进行切分。

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

PerceiverModel

class transformers.PerceiverModel

< >

( config decoder = 无 input_preprocessor: typing.Callable[..., typing.Tuple[torch.Tensor, typing.Optional[torch.Tensor], torch.Tensor]] = 无 output_postprocessor: typing.Callable[..., typing.Any] = 无 )

参数

  • config (PerceiverConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法加载模型权重。
  • decoder (DecoderType, 可选) — 可选的解码器,用于解码编码器的潜在表示。示例包括 transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder, transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder, transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder
  • input_preprocessor (PreprocessorType, 可选) — 可选的输入预处理器。示例包括 transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor, transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor, transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor, transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor
  • output_postprocessor (PostprocessorType, 可选) — 可选的输出后处理器。示例包括 transformers.models.perceiver.modeling_perceiver.PerceiverImagePostprocessor, transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor, transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor, transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor, transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor
  • 注意,您可以定义自己的解码器、预处理器和/或后处理器以适应您的用例。 —

Perceiver:一种可扩展的、完全基于注意力的架构。

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

此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以获取与通用用法和行为相关的所有事项。

前向传播

< >

( inputs: FloatTensor attention_mask: typing.Optional[torch.FloatTensor] = 无 subsampled_output_points: typing.Optional[typing.Dict[str, torch.Tensor]] = 无 head_mask: typing.Optional[torch.FloatTensor] = 无 output_attentions: typing.Optional[bool] = 无 output_hidden_states: typing.Optional[bool] = 无 interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = 无 ) transformers.models.perceiver.modeling_perceiver.PerceiverModelOutputtuple(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)可选) — 用于使自注意力模块中选定的 head 失效的掩码。掩码值在 [0, 1] 中选择:

    • `1` 表示 head **未被掩码**,
    • `0` 表示 head **被掩码**。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 `attentions`。
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 `hidden_states`。
  • interpolate_pos_encoding (bool可选,默认为 False) — 是否插值预训练的位置编码。
  • return_dict (bool可选) — 是否返回 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 (torch.FloatTensor,形状为 (batch_size, num_labels)) — 分类(或回归,如果 `config.num_labels==1`)得分(在 SoftMax 之前)。
  • last_hidden_state (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — `torch.FloatTensor` 的元组(embeddings 的输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重,用于计算自注意力 head 中的加权平均。
  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力 head 中的加权平均。

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

transformers.PerceiverForMaskedLM

< >

( config: PerceiverConfig )

参数

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

Perceiver 用于掩码语言建模的示例用法。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以获取与通用用法和行为相关的所有事项。

前向传播

< >

( inputs: typing.Optional[torch.Tensor] = 无 attention_mask: typing.Optional[torch.Tensor] = 无 head_mask: typing.Optional[torch.Tensor] = 无 output_attentions: typing.Optional[bool] = 无 output_hidden_states: typing.Optional[bool] = 无 labels: typing.Optional[torch.Tensor] = 无 return_dict: typing.Optional[bool] = 无 input_ids: typing.Optional[torch.Tensor] = 无 ) transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutputtuple(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)可选) — 用于使自注意力模块中选定的 head 失效的掩码。掩码值在 [0, 1] 中选择:

    • `1` 表示 head **未被掩码**,
    • `0` 表示 head **被掩码**。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 `attentions`。
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 `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` 的 tokens 将被忽略(遮蔽),损失函数仅针对标签在 `[0, ..., config.vocab_size]` 中的 tokens 计算。

返回:

transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput or tuple(torch.FloatTensor)

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

  • loss (torch.FloatTensor,形状为 (1,),*可选*,当提供 `labels` 时返回) — 遮蔽语言模型 (MLM) 损失。
  • logits (torch.FloatTensor,形状为 (batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测得分(每个词汇 token 在 SoftMax 之前的得分)。
  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — `torch.FloatTensor` 的元组(embeddings 的输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (`tuple(torch.FloatTensor)`,*可选*,当传递 `output_attentions=True` 或当 `config.output_attentions=True` 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 `(batch_size, num_heads, num_latents, num_latents)`。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力 head 中的加权平均。

PerceiverForMaskedLMforward 方法,覆盖了 __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

class transformers.PerceiverForSequenceClassification

< >

( config )

参数

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

Perceiver 用于文本分类的示例用法。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

前向传播

< >

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

参数

  • inputs (torch.FloatTensor) — Perceiver 的输入。可以是任何内容:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor,形状为 batch_size, sequence_length,*可选*) — 用于避免对 padding token 索引执行注意力的 Mask。Mask 值在 `[0, 1]` 中选择:

    • `1` 表示 tokens 未被遮蔽
    • `0` 表示 tokens 已被遮蔽

    什么是注意力掩码?

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

    • `1` 表示 head 未被遮蔽
    • `0` 表示 head 已被遮蔽
  • output_attentions (bool, *可选*) — 是否返回所有注意力层的注意力 tensors。有关更多详细信息,请参阅返回的 tensors 下的 `attentions`。
  • output_hidden_states (bool, *可选*) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的 tensors 下的 `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.PerceiverClassifierOutput or tuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或一个 `torch.FloatTensor` 元组 (如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),包含各种元素,具体取决于配置 (PerceiverConfig) 和输入。

  • 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` 的元组(embeddings 的输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重,用于计算自注意力 head 中的加权平均。
  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力 head 中的加权平均。

PerceiverForSequenceClassificationforward 方法,覆盖了 __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

class transformers.PerceiverForImageClassificationLearned

< >

( config )

参数

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

Perceiver 用于图像分类的示例用法,例如 ImageNet 等任务。

此模型使用学习的位置嵌入。换句话说,此模型没有获得关于图像结构的任何特权信息。正如论文中所示,此模型可以在 ImageNet 上实现 72.7 的 top-1 准确率。

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

此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以获取与通用用法和行为相关的所有事项。

前向传播

< >

( inputs: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None pixel_values: typing.Optional[torch.Tensor] = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput or tuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — Perceiver 的输入。可以是任何内容:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor,形状为 batch_size, sequence_length,*可选*) — 用于避免对 padding token 索引执行注意力的 Mask。Mask 值在 `[0, 1]` 中选择:

    • `1` 表示 tokens 未被遮蔽
    • `0` 表示 tokens 已被遮蔽

    什么是注意力掩码?

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

    • `1` 表示 head 未被遮蔽
    • `0` 表示 head 已被遮蔽
  • output_attentions (bool, *可选*) — 是否返回所有注意力层的注意力 tensors。有关更多详细信息,请参阅返回的 tensors 下的 `attentions`。
  • output_hidden_states (bool, *可选*) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的 tensors 下的 `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.PerceiverClassifierOutput or tuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或一个 `torch.FloatTensor` 元组 (如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),包含各种元素,具体取决于配置 (PerceiverConfig) 和输入。

  • 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` 的元组(embeddings 的输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重,用于计算自注意力 head 中的加权平均。
  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力 head 中的加权平均。

PerceiverForImageClassificationLearned 的 forward 方法,覆盖了 __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

class transformers.PerceiverForImageClassificationFourier

< >

( config )

参数

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

Perceiver 用于图像分类的示例用法,例如 ImageNet 等任务。

此模型使用固定的 2D 傅里叶位置嵌入。正如论文中所示,此模型在 ImageNet 上可以达到 79.0 的 top-1 准确率,并且在大型数据集(即 JFT)上预训练时可以达到 84.5。

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

此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以获取与通用用法和行为相关的所有事项。

前向传播

< >

( inputs: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None return_dict: typing.Optional[bool] = None pixel_values: typing.Optional[torch.Tensor] = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — Perceiver 的输入。可以是任何内容:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor,形状为 batch_size, sequence_length可选) — 用于避免在 padding 标记索引上执行注意力的掩码。掩码值在 [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.PerceiverClassifierOutput or tuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或一个 `torch.FloatTensor` 元组 (如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),包含各种元素,具体取决于配置 (PerceiverConfig) 和输入。

  • 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` 的元组(embeddings 的输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重,用于计算自注意力 head 中的加权平均。
  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力 head 中的加权平均。

PerceiverForImageClassificationFourier 的 forward 方法,覆盖了 __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

class 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: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None return_dict: typing.Optional[bool] = None pixel_values: typing.Optional[torch.Tensor] = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — Perceiver 的输入。可以是任何内容:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor,形状为 batch_size, sequence_length可选) — 用于避免在 padding 标记索引上执行注意力的掩码。掩码值在 [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.PerceiverClassifierOutput or tuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或一个 `torch.FloatTensor` 元组 (如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),包含各种元素,具体取决于配置 (PerceiverConfig) 和输入。

  • 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` 的元组(embeddings 的输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重,用于计算自注意力 head 中的加权平均。
  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力 head 中的加权平均。

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

class transformers.PerceiverForOpticalFlow

< >

( config )

参数

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

Perceiver 光流的示例用法,用于 Sintel 和 KITTI 等任务。PerceiverForOpticalFlow 使用 PerceiverImagePreprocessor (使用 prep_type=“patches”) 预处理输入图像,并使用 PerceiverOpticalFlowDecoder 解码 PerceiverModel 的潜在表示。

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

此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以获取与通用用法和行为相关的所有事项。

前向传播

< >

( inputs: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None return_dict: typing.Optional[bool] = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — Perceiver 的输入。可以是任何内容:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor,形状为 batch_size, sequence_length可选) — 用于避免对填充 token 索引执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 token 未被掩蔽
    • 0 表示 token 已被掩蔽

    什么是 attention 掩码?

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

    • 1 表示 head 未被掩蔽
    • 0 表示 head 已被掩蔽
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attention tensors。 有关更多详细信息,请参阅返回的 tensors 下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回的 tensors 下的 hidden_states
  • interpolate_pos_encoding (bool可选,默认为 False) — 是否插值预训练的位置编码。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通的 tuple。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算光流损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

返回:

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput or tuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或一个 `torch.FloatTensor` 元组 (如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),包含各种元素,具体取决于配置 (PerceiverConfig) 和输入。

  • 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` 的元组(embeddings 的输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重,用于计算自注意力 head 中的加权平均。
  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力 head 中的加权平均。

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

class transformers.PerceiverForMultimodalAutoencoding

< >

( config: PerceiverConfig )

参数

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

Perceiver 多模态(视频)自动编码的示例用法,用于 Kinetics-700 等任务。

PerceiverForMultimodalAutoencoding 使用 PerceiverMultimodalPreprocessor 预处理 3 种模态:图像、音频和类别标签。此预处理器使用特定于模态的预处理器分别预处理每种模态,然后将它们连接起来。可训练的位置嵌入用于将每种模态填充到相同数量的通道,以使沿时间维度的连接成为可能。接下来,应用 Perceiver 编码器。

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

PerceiverMultimodalDecoder 还将不同模态的解码器查询填充到相同数量的通道,以便沿时间维度连接它们。接下来,使用 PerceiverModel 的潜在表示执行交叉注意力。

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

请注意,通过在评估期间掩蔽分类标签(即,仅为“标签”模态提供零张量),此自动编码模型将成为 Kinetics 700 视频分类器。

此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以获取与通用用法和行为相关的所有事项。

前向传播

< >

( inputs: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None subsampled_output_points: typing.Optional[typing.Dict[str, torch.Tensor]] = None head_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None return_dict: typing.Optional[bool] = None ) transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutputtuple(torch.FloatTensor)

参数

  • inputs (torch.FloatTensor) — Perceiver 的输入。可以是任何内容:图像、文本、音频、视频等。
  • attention_mask (torch.FloatTensor,形状为 batch_size, sequence_length可选) — 用于避免对填充 token 索引执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 token 未被掩蔽
    • 0 表示 token 已被掩蔽

    什么是 attention 掩码?

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

    • 1 表示 head 未被掩蔽
    • 0 表示 head 已被掩蔽
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attention tensors。 有关更多详细信息,请参阅返回的 tensors 下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回的 tensors 下的 hidden_states
  • interpolate_pos_encoding (bool可选,默认为 False) — 是否插值预训练的位置编码。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通的 tuple。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1,则计算回归损失(均方损失)。如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回:

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput or tuple(torch.FloatTensor)

一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或一个 `torch.FloatTensor` 元组 (如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),包含各种元素,具体取决于配置 (PerceiverConfig) 和输入。

  • 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` 的元组(embeddings 的输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重,用于计算自注意力 head 中的加权平均。
  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — `torch.FloatTensor` 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力 head 中的加权平均。

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 上更新