Transformers 文档
Perceiver
并获得增强的文档体验
开始使用
Perceiver
概述
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: A General Architecture for Structured Inputs & Outputs 中提出。
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 个 token。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 个 token 中的某些，可以将 outputs 定义为形状：(batch_size, 2048, 768)。接下来，与潜在变量的最终隐藏状态进行交叉注意力，以更新 outputs 张量。交叉注意力之后，仍然有一个形状为 (batch_size, 2048, 768) 的张量。然后可以在其上方放置一个常规的语言建模头，将最后一维投影到模型的词汇表大小，即创建形状为 (batch_size, 2048, 262) 的 logits（因为 Perceiver 使用的词汇表大小为 262 个字节 ID）。
Perceiver IO 架构。摘自 原始论文 由于 PyTorch 中的一个 bug，Perceiver 不 支持 torch.nn.DataParallel，详情请参阅 issue #36035
资源
- 快速开始使用 Perceiver 的最快方法是查看 教程笔记本。
- 如果您想完全了解模型的工作原理以及在库中的实现方式，请参阅 博客文章。请注意，库中提供的模型只展示了 Perceiver 的一些示例用途。还有更多用例，包括问答、命名实体识别、目标检测、音频分类、视频分类等。
- 文本分类任务指南
- 掩码语言建模任务指南
- 图像分类任务指南
Perceiver 特有输出
class transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput
< 源代码 >( logits: typing.Optional[torch.FloatTensor] = None last_hidden_state: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[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), 可选, 默认为None) — 模型最后一层的隐藏状态序列。 - 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 基础模型输出的基类，包含潜在隐藏状态、注意力机制和交叉注意力机制。
class transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput
< 源代码 >( logits: typing.Optional[torch.FloatTensor] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )
参数
- logits (
torch.FloatTensor形状为(batch_size, num_labels)) — 基本解码器的输出。 - cross_attentions (
tuple[torch.FloatTensor], 可选, 当传入output_attentions=True或config.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: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = None )
参数
- loss (
torch.FloatTensor形状为(1,), 可选, 当提供labels时返回) — 掩码语言建模（MLM）损失。 - logits (
torch.FloatTensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。 - 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 掩码语言模型输出的基类。
class transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput
< 源代码 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor]] = 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
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) — 潜在变量的数量。 - 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_factor (
int, 可选, 默认为 1) — Transformer 编码器自注意力层中的前馈层维度。 - hidden_act (
str或function, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。 - attention_probs_dropout_prob (
float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。 - use_query_residual (
float, 可选, 默认为True) — 是否在编码器的交叉注意力层中添加查询残差。 - 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_frame (
int, 可选, 默认为 1920) — 用于多模态自编码模型的每帧音频样本数。 - samples_per_patch (
int, 可选, 默认为 16) — 在对多模态自编码模型的音频进行预处理时，每个补丁的音频样本数。 - output_shape (
list[int], 可选, 默认为[1, 16, 224, 224]) — 多模态自编码模型视频解码器查询的输出形状 (batch_size, num_frames, height, width)。这不包括通道维度。 - output_num_channels (
int, 可选, 默认为 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.configPerceiverTokenizer
class transformers.PerceiverTokenizer
< source >( 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]") — 序列结束标记（在词汇表中保留，但实际上未使用）。使用特殊标记构建序列时，这不是序列结束使用的标记。使用的标记是
sep_token。 - mask_token (
str, 可选, 默认为"[MASK]") — MASK 标记，用于掩码语言模型。 - cls_token (
str, 可选, 默认为"[CLS]") — CLS 标记（在词汇表中保留，但实际上未使用）。 - sep_token (
str, 可选, 默认为"[SEP]") — 分隔符标记，用于从两个序列构建序列。
构建 Perceiver 分词器。Perceiver 仅使用原始字节 utf-8 编码。
此分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应查阅此超类以获取有关这些方法的更多信息。
__call__
< source >( text: typing.Union[str, list[str], list[list[str]], NoneType] = None text_pair: typing.Union[str, list[str], list[list[str]], NoneType] = None text_target: typing.Union[str, list[str], list[list[str]], NoneType] = None text_pair_target: typing.Union[str, list[str], list[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, NoneType] = 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 中。如果您想自动添加bos或eos标记，这会很有用。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为False) — 激活并控制填充。接受以下值：True或'longest': 填充到批次中最长的序列（如果只提供单个序列则不填充）。'max_length': 填充到由max_length参数指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'（默认）: 不填充（即，可以输出序列长度不同的批次）。
- truncation (
bool,str或 TruncationStrategy, 可选, 默认为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。这对于在 NVIDIA 硬件上使用计算能力>= 7.5(Volta) 的 Tensor Core 尤其有用。 - padding_side (
str, 可选) — 模型应在其上应用填充的一侧。应在“[‘right’, ‘left’]”之间选择。默认值从同名的类属性中选择。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, 可选) — 是否返回标记类型 ID。如果保留默认值，将根据特定分词器的默认设置（由return_outputs属性定义）返回标记类型 ID。 - return_attention_mask (
bool, 可选) — 是否返回注意力掩码。如果保留默认值，将根据特定分词器的默认设置（由return_outputs属性定义）返回注意力掩码。 - return_overflowing_tokens (
bool, optional, 默认为False) — 是否返回溢出的 token 序列。如果提供了输入 ID 的序列对（或成批序列对），且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出 token。 - return_special_tokens_mask (
bool, optional, 默认为False) — 是否返回特殊 token 掩码信息。 - return_offsets_mapping (
bool, optional, 默认为False) — 是否为每个 token 返回(char_start, char_end)。此功能仅适用于继承自 PreTrainedTokenizerFast 的快速分词器，如果使用 Python 的分词器，此方法将引发
NotImplementedError。 - return_length (
bool, optional, 默认为False) — 是否返回编码输入的长度。 - verbose (
bool, optional, 默认为True) — 是否打印更多信息和警告。 - **kwargs — 传递给
self.tokenize()方法
一个 BatchEncoding，包含以下字段：
-
input_ids — 要输入到模型中的标记 ID 列表。
-
token_type_ids — 要输入到模型中的标记类型 ID 列表（当
return_token_type_ids=True或如果 *“token_type_ids”* 在self.model_input_names中时）。 -
attention_mask — 指定模型应关注哪些标记的索引列表（当
return_attention_mask=True或如果 *“attention_mask”* 在self.model_input_names中时）。 -
overflowing_tokens — 溢出标记序列列表（当指定
max_length且return_overflowing_tokens=True时）。 -
num_truncated_tokens — 截断标记的数量（当指定
max_length且return_overflowing_tokens=True时）。 -
special_tokens_mask — 0 和 1 的列表，其中 1 表示添加的特殊标记，0 表示常规序列标记（当
add_special_tokens=True且return_special_tokens_mask=True时）。 -
length — 输入的长度（当
return_length=True时）
将一个或多个序列或一对或多对序列标记化并准备用于模型的主要方法。
PerceiverFeatureExtractor
预处理单张或批量图像。
PerceiverImageProcessor
class transformers.PerceiverImageProcessor
< source 源代码 >( do_center_crop: bool = True crop_size: typing.Optional[dict[str, int]] = None do_resize: bool = True size: typing.Optional[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, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = 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参数覆盖。 - size (
dict[str, int]optional, 默认为{"height" -- 224, "width": 224})：调整大小后图像的尺寸。可通过preprocess方法中的size参数覆盖。 - resample (
PILImageResampling, optional, 默认为PILImageResampling.BICUBIC) — 定义调整图像大小时使用的重采样滤镜。可通过preprocess方法中的resample参数覆盖。 - do_rescale (
bool, optional, 默认为True) — 是否通过指定的缩放因子rescale_factor对图像进行缩放。可通过preprocess方法中的do_rescale参数覆盖。 - rescale_factor (
int或float, optional, 默认为1/255) — 定义缩放图像时使用的缩放因子。可通过preprocess方法中的rescale_factor参数覆盖。 - do_normalize — 是否对图像进行归一化。可通过
preprocess方法中的do_normalize参数覆盖。 - image_mean (
float或list[float], optional, 默认为IMAGENET_STANDARD_MEAN) — 图像归一化时使用的均值。这是一个浮点数或浮点数列表，其长度与图像中的通道数相同。可通过preprocess方法中的image_mean参数覆盖。 - image_std (
float或list[float], optional, 默认为IMAGENET_STANDARD_STD) — 图像归一化时使用的标准差。这是一个浮点数或浮点数列表，其长度与图像中的通道数相同。可通过preprocess方法中的image_std参数覆盖。
构建一个 Perceiver 图像处理器。
预处理
< source 源代码 >( 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[dict[str, int]] = None do_resize: typing.Optional[bool] = None size: typing.Optional[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, list[float], NoneType] = None image_std: typing.Union[float, 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, optional, 默认为self.do_center_crop) — 是否将图像中心裁剪为crop_size。 - crop_size (
dict[str, int], optional, 默认为self.crop_size) — 应用中心裁剪后的期望输出尺寸。 - do_resize (
bool, optional, 默认为self.do_resize) — 是否调整图像大小。 - size (
dict[str, int], optional, 默认为self.size) — 调整大小后图像的尺寸。 - resample (
int, optional, 默认为self.resample) — 调整图像大小时使用的重采样滤镜。可以是枚举类型PILImageResampling之一。仅当do_resize设置为True时有效。 - do_rescale (
bool, optional, 默认为self.do_rescale) — 是否缩放图像。 - rescale_factor (
float, optional, 默认为self.rescale_factor) — 如果do_rescale设置为True，则用于缩放图像的缩放因子。 - do_normalize (
bool, optional, 默认为self.do_normalize) — 是否对图像进行归一化。 - image_mean (
float或list[float], optional, 默认为self.image_mean) — 图像均值。 - image_std (
float或list[float], optional, 默认为self.image_std) — 图像标准差。 - return_tensors (
str或TensorType, optional) — 返回张量的类型。可以是以下之一：- 未设置：返回
np.ndarray列表。 TensorType.TENSORFLOW或'tf'：返回tf.Tensor类型的批次。TensorType.PYTORCH或'pt'：返回torch.Tensor类型的批次。TensorType.NUMPY或'np'：返回np.ndarray类型的批次。TensorType.JAX或'jax'：返回jax.numpy.ndarray类型的批次。
- 未设置：返回
- data_format (
ChannelDimension或str, optional, 默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。ChannelDimension.LAST：图像格式为 (height, width, num_channels)。
- input_data_format (
ChannelDimension或str, optional) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST：图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE：图像格式为 (height, width)。
预处理一张或一批图像。
PerceiverImageProcessorFast
class transformers.PerceiverImageProcessorFast
< source 源代码 >( **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] )
构建一个快速 Perceiver 图像处理器。
预处理
< source 源代码 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] *args **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] ) → <class 'transformers.image_processing_base.BatchFeature'>
参数
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]) — 要预处理的图像。期望单个或批次图像的像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间，请设置do_rescale=False。 - do_resize (
bool, optional) — 是否调整图像大小。 - size (
dict[str, int], optional) — 描述模型的最大输入尺寸。 - default_to_square (
bool, optional) — 当调整大小（如果尺寸为整数）时，是否默认为方形图像。 - resample (
Union[PILImageResampling, F.InterpolationMode, NoneType]) — 调整图像大小时使用的重采样滤镜。可以是枚举类型PILImageResampling之一。仅当do_resize设置为True时有效。 - do_center_crop (
bool, optional) — 是否对图像进行中心裁剪。 - crop_size (
dict[str, int], optional) — 应用center_crop后输出图像的尺寸。 - do_rescale (
bool, optional) — 是否缩放图像。 - rescale_factor (
Union[int, float, NoneType]) — 如果do_rescale设置为True，则用于缩放图像的缩放因子。 - do_normalize (
bool, optional) — 是否对图像进行归一化。 - image_mean (
Union[float, list[float], NoneType]) — 用于归一化的图像均值。仅当do_normalize设置为True时有效。 - image_std (
Union[float, list[float], NoneType]) — 用于归一化的图像标准差。仅当do_normalize设置为True时有效。 - do_convert_rgb (
bool, optional) — 是否将图像转换为 RGB 格式。 - return_tensors (
Union[str, ~utils.generic.TensorType, NoneType]) — 如果设置为pt，则返回堆叠的张量，否则返回张量列表。 - data_format (
~image_utils.ChannelDimension, optional) — 仅支持ChannelDimension.FIRST。为与慢速处理器兼容而添加。 - input_data_format (
Union[str, ~image_utils.ChannelDimension, NoneType]) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST：图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE：图像格式为 (height, width)。
- device (
torch.device, optional) — 处理图像的设备。如果未设置，则从输入图像推断设备。 - disable_grouping (
bool, optional) — 是否禁用按大小对图像进行分组以单独处理而不是分批处理。如果为 None，则如果图像在 CPU 上，将设置为 True，否则设置为 False。此选择基于经验观察，详情请参阅：https://github.com/huggingface/transformers/pull/38157
返回
<class 'transformers.image_processing_base.BatchFeature'>
- data (
dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。 - tensor_type (
Union[None, str, TensorType], 可选) — 您可以在此处提供一个`tensor_type`，以便在初始化时将整数列表转换为PyTorch/TensorFlow/Numpy张量。
PerceiverTextPreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor
< source >( config: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型配置。
Perceiver 编码器的文本预处理。可用于嵌入 inputs 并添加位置编码。
嵌入的维度由配置的 d_model 属性决定。
PerceiverImagePreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor
< source >( 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, optional, 默认为"conv") — 预处理类型。可以是 “conv1x1”、“conv”、“patches” 或 “pixels”。 - spatial_downsample (
int, optional, 默认为 4) — 空间下采样因子。 - temporal_downsample (
int, optional, 默认为 1) — 时间下采样因子（仅在存在时间维度时相关）。 - position_encoding_type (
str, optional, 默认为"fourier") — 位置编码类型。可以是“fourier”或“trainable”。 - in_channels (
int, optional, 默认为 3) — 输入中的通道数。 - out_channels (
int, optional, 默认为 64) — 输出中的通道数。 - conv_after_patching (
bool, optional, 默认为False) — 打补丁后是否应用卷积层。 - conv_after_patching_in_channels (
int, optional, 默认为 54) — 打补丁后卷积层输入的通道数。 - conv2d_use_batchnorm (
bool, optional, 默认为True) — 是否在卷积层中使用批归一化。 - concat_or_add_pos (
str, optional, 默认为"concat") — 如何将位置编码连接到输入。可以是“concat”或“add”。 - project_pos_dim (
int, optional, 默认为 -1) — 要投影到的位置编码的维度。如果为 -1，则不应用投影。 - **position_encoding_kwargs (
Dict, optional) — 位置编码的关键字参数。
Perceiver 编码器的图像预处理。
注意：如果 prep_type 设置为 “conv1x1” 或 “conv”，则 out_channels 参数指的是卷积层的输出通道。如果添加绝对位置嵌入，则必须确保位置编码 kwargs 的 num_channels 设置等于 out_channels。
PerceiverOneHotPreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor
< source >( config: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型配置。
Perceiver 编码器的一热预处理器。可用于向输入添加虚拟索引维度。
PerceiverAudioPreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor
< source >( 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, 默认为"patches") — 要使用的预处理器类型。仅支持“patches”。 - samples_per_patch (
int, optional, 默认为 96) — 每个补丁的样本数。 - position_encoding_type (
str, optional, 默认为"fourier") — 要使用的位置编码类型。可以是“trainable”或“fourier”。 - concat_or_add_pos (
str, optional, 默认为"concat") — 如何将位置编码连接到输入。可以是“concat”或“add”。 - out_channels (
int, optional, 默认为 64) — 输出中的通道数。 - project_pos_dim (
int, optional, 默认为 -1) — 要投影到的位置编码的维度。如果为 -1，则不应用投影。 - **position_encoding_kwargs (
Dict, optional) — 位置编码的关键字参数。
Perceiver 编码器的音频预处理。
PerceiverMultimodalPreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor
< source >( modalities: Mapping mask_probs: typing.Optional[collections.abc.Mapping[str, float]] = None min_padding_size: int = 2 )
Perceiver 编码器的多模态预处理。
对每个模态的输入进行预处理，然后用可训练的位置嵌入进行填充，使其具有相同的通道数。
PerceiverProjectionDecoder
class transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder
< source >( config )
参数
- config (PerceiverConfig) — 模型配置。
基线投影解码器（无交叉注意力）。
PerceiverBasicDecoder
class transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder
< source >( 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 )
参数
- config (PerceiverConfig) — 模型配置。
基于交叉注意力的分类解码器。`PerceiverBasicDecoder` 的轻量级封装，用于输出 logits。将 Perceiver 编码器的输出从 (batch_size, num_latents, d_latents) 形状转换为 (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: list position_encoding_type: str **decoder_kwargs )
基于交叉注意力的视频自编码解码器。`[PerceiverBasicDecoder]` 的轻量级封装，具有视频重塑逻辑。
PerceiverMultimodalDecoder
class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder
< 源 >( config: PerceiverConfig modalities: dict num_outputs: int output_num_channels: int min_padding_size: typing.Optional[int] = 2 subsampled_index_dims: typing.Optional[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, 默认为 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 )
Perceiver 的投影后处理。可用于将解码器输出的通道投影到更低的维度。
PerceiverAudioPostprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor
< 源 >( config: PerceiverConfig in_channels: int postproc_type: str = 'patches' )
Perceiver 的音频后处理。可用于将解码器输出转换为音频特征。
PerceiverClassificationPostprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor
< 源 >( config: PerceiverConfig in_channels: int )
Perceiver 的分类后处理。可用于将解码器输出转换为分类 logits。
PerceiverMultimodalPostprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor
< 源 >( modalities: Mapping input_is_dict: bool = False )
Perceiver 的多模态后处理。可用于将模态特定的后处理器组合成一个单一的后处理器。
PerceiverModel
class transformers.PerceiverModel
< 源 >( config decoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = None input_preprocessor: typing.Callable[..., tuple[torch.Tensor, typing.Optional[torch.Tensor], torch.Tensor]] = None output_postprocessor: typing.Callable[..., typing.Any] = None )
参数
- config (PerceiverModel) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查阅 from_pretrained() 方法以加载模型权重。
- decoder (
PerceiverDecoder, optional) — 解码器模块，将潜在表示转换为任务预测。 - input_preprocessor (
PreprocessorType, optional) — 预处理器，将原始输入编码为模型的张量。 - output_postprocessor (
PostprocessorType, optional) — 后处理器，将模型输出转换为最终预测。
感知器：一种可扩展的、完全注意力的架构。
请注意，通过在模型的 `forward` 中将 `interpolate_pos_encoding` 设置为 `True`，可以对分辨率高于训练时使用的图像进行 Perceiver 微调。这将把预训练的位置嵌入插值到更高的分辨率。
该模型继承自 PreTrainedModel。请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
前向
< 源 >( inputs: FloatTensor attention_mask: typing.Optional[torch.FloatTensor] = None subsampled_output_points: typing.Optional[dict[str, torch.Tensor]] = None head_mask: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None ) → transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.FloatTensor) — Perceiver 的输入。可以是任何类型：图像、文本、音频、视频等。 - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为[0, 1]：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- subsampled_output_points (
dict[str, torch.Tensor]，可选) — 用作解码器查询的张量字典。解码器将这些查询映射到模型的潜在表示。用于子采样解码，例如仅解码某些图像块时。 - 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 而不是普通元组。
返回
transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput 或 tuple(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 (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选，默认为None) — 模型最后一层输出的隐藏状态序列。 -
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 之后，用于计算交叉注意力头中的加权平均。
PerceiverModel 的前向传播方法，覆盖了 __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 用于掩码语言建模的示例用法。
该模型继承自 PreTrainedModel。请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是 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.PerceiverMaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.Tensor，可选) — Perceiver 的输入。可以是任何类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为[0, 1]：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于禁用自注意力模块中选定头的掩码。掩码值选择范围为[0, 1]：- 1 表示头部未被掩码，
- 0 表示头部被掩码。
- output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量下的hidden_states。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内 (请参阅input_ids文档字符串)。索引设置为-100的标记将被忽略 (被掩码)，损失仅针对标签在[0, ..., config.vocab_size]范围内的标记计算。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
返回
transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput 或 torch.FloatTensor 的元组 (如果传入 return_dict=False 或 config.return_dict=False 时)，包含根据配置 (PerceiverConfig) 和输入而变化的各种元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 掩码语言建模 (MLM) 损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
hidden_states (
tuple[torch.FloatTensor]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (如果模型有嵌入层，则包括嵌入层的输出，加上每一层的输出)，形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple[torch.FloatTensor]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组 (每一层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
-
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
class transformers.PerceiverForSequenceClassification
< 源 >( config )
参数
- config (PerceiverForSequenceClassification) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法以加载模型权重。
Perceiver 用于文本分类的示例用法。
该模型继承自 PreTrainedModel。请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是 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 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.Tensor，可选) — Perceiver 的输入。可以是任何类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为[0, 1]：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于禁用自注意力模块中选定头的掩码。掩码值选择范围为[0, 1]：- 1 表示头部未被掩码，
- 0 表示头部被掩码。
- output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量下的hidden_states。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失 (均方损失)；如果config.num_labels > 1，则计算分类损失 (交叉熵)。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
返回
transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 torch.FloatTensor 的元组 (如果传入 return_dict=False 或 config.return_dict=False 时)，包含根据配置 (PerceiverConfig) 和输入而变化的各种元素。
-
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=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 之后，用于计算交叉注意力头中的加权平均。
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
class transformers.PerceiverForImageClassificationLearned
< 源 >( config )
参数
- config (PerceiverForImageClassificationLearned) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法以加载模型权重。
Perceiver 用于图像分类（如 ImageNet 任务）的示例用法。
此模型使用学习到的位置嵌入。换句话说，此模型不提供任何关于图像结构的特权信息。如论文所示，该模型可以在 ImageNet 上达到 72.7 的 top-1 准确率。
PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor (使用 prep_type="conv1x1") 来预处理输入图像，并使用 PerceiverClassificationDecoder 将 PerceiverModel 的潜在表示解码为分类 logits。
该模型继承自 PreTrainedModel。请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是 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 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.Tensor，可选) — Perceiver 的输入。可以是任何类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为[0, 1]：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于禁用自注意力模块中选定头的掩码。掩码值选择范围为[0, 1]：- 1 表示头部未被掩码，
- 0 表示头部被掩码。
- output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量下的hidden_states。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵损失）。 - interpolate_pos_encoding (
bool，默认为False) — 是否对预训练的位置编码进行插值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。 - pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。像素值可以使用{image_processor_class}获取。有关详细信息，请参见{image_processor_class}.__call__（{processor_class}使用{image_processor_class}处理图像）。
返回
transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 torch.FloatTensor 的元组 (如果传入 return_dict=False 或 config.return_dict=False 时)，包含根据配置 (PerceiverConfig) 和输入而变化的各种元素。
-
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=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 之后，用于计算交叉注意力头中的加权平均。
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 catPerceiverForImageClassificationFourier
class transformers.PerceiverForImageClassificationFourier
< source >( config )
参数
- config (PerceiverForImageClassificationFourier) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查阅 from_pretrained() 方法以加载模型权重。
Perceiver 用于图像分类（如 ImageNet 任务）的示例用法。
该模型使用固定的二维傅里叶位置嵌入。正如论文所示，该模型在 ImageNet 上可以达到 79.0 的 Top-1 准确率，在大型数据集（即 JFT）上预训练后可以达到 84.5。
PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor (prep_type="pixels") 来预处理输入图像，并使用 PerceiverClassificationDecoder 将 PerceiverModel 的潜在表示解码为分类 logits。
该模型继承自 PreTrainedModel。请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
前向
< source >( 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.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.Tensor，可选) — Perceiver 的输入。可以是任何类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充令牌索引执行注意力操作的掩码。掩码值选择在[0, 1]之间：- 1 表示令牌**未被掩码**，
- 0 表示令牌**已被掩码**。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]之间：- 1 表示头部**未被掩码**，
- 0 表示头部**已被掩码**。
- output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵损失）。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。 - pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。像素值可以使用{image_processor_class}获取。有关详细信息，请参见{image_processor_class}.__call__（{processor_class}使用{image_processor_class}处理图像）。
返回
transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 torch.FloatTensor 的元组 (如果传入 return_dict=False 或 config.return_dict=False 时)，包含根据配置 (PerceiverConfig) 和输入而变化的各种元素。
-
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=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 之后，用于计算交叉注意力头中的加权平均。
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 catPerceiverForImageClassificationConvProcessing
class transformers.PerceiverForImageClassificationConvProcessing
< source >( config )
参数
- config (PerceiverForImageClassificationConvProcessing) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查阅 from_pretrained() 方法以加载模型权重。
Perceiver 用于图像分类（如 ImageNet 任务）的示例用法。
该模型使用一个二维卷积+最大池化预处理网络。正如论文所示，该模型在 ImageNet 上可以达到 82.1 的 Top-1 准确率。
PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor (prep_type="conv") 来预处理输入图像，并使用 PerceiverClassificationDecoder 将 PerceiverModel 的潜在表示解码为分类 logits。
该模型继承自 PreTrainedModel。请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
前向
< source >( 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.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.Tensor，可选) — Perceiver 的输入。可以是任何类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充令牌索引执行注意力操作的掩码。掩码值选择在[0, 1]之间：- 1 表示令牌**未被掩码**，
- 0 表示令牌**已被掩码**。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]之间：- 1 表示头部**未被掩码**，
- 0 表示头部**已被掩码**。
- output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵损失）。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。 - pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。像素值可以使用{image_processor_class}获取。有关详细信息，请参见{image_processor_class}.__call__（{processor_class}使用{image_processor_class}处理图像）。
返回
transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 torch.FloatTensor 的元组 (如果传入 return_dict=False 或 config.return_dict=False 时)，包含根据配置 (PerceiverConfig) 和输入而变化的各种元素。
-
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=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 之后，用于计算交叉注意力头中的加权平均。
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 catPerceiverForOpticalFlow
class transformers.PerceiverForOpticalFlow
< source >( config )
参数
- config (PerceiverForOpticalFlow) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查阅 from_pretrained() 方法以加载模型权重。
Perceiver 用于光流的示例用法，适用于 Sintel 和 KITTI 等任务。PerceiverForOpticalFlow 使用 PerceiverImagePreprocessor (使用 _prep_type="patches"_ ) 预处理输入图像，并使用 PerceiverOpticalFlowDecoder 解码 PerceiverModel 的潜在表示。
作为输入，将两个连续帧沿通道维度拼接，并围绕每个像素提取一个 3x3 块（每个像素有 3x3x3x2 = 54 个值）。固定傅里叶位置编码用于编码补丁中每个像素的位置。接下来，应用感知器编码器。为了解码，使用与输入相同的编码来查询潜在表示。
该模型继承自 PreTrainedModel。请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
前向
< source >( 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.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.Tensor，可选) — Perceiver 的输入。可以是任何类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充令牌索引执行注意力操作的掩码。掩码值选择在[0, 1]之间：- 1 表示令牌**未被掩码**，
- 0 表示令牌**已被掩码**。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]之间：- 1 表示头部**未被掩码**，
- 0 表示头部**已被掩码**。
- output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算光流损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。
返回
transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 torch.FloatTensor 的元组 (如果传入 return_dict=False 或 config.return_dict=False 时)，包含根据配置 (PerceiverConfig) 和输入而变化的各种元素。
-
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=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 之后，用于计算交叉注意力头中的加权平均。
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
< source >( 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 视频分类器。
该模型继承自 PreTrainedModel。请查阅超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
前向
< source >( inputs: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None subsampled_output_points: typing.Optional[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.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.Tensor，可选) — Perceiver 的输入。可以是任何类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充令牌索引执行注意力操作的掩码。掩码值选择在[0, 1]之间：- 1 表示令牌**未被掩码**，
- 0 表示令牌**已被掩码**。
- subsampled_output_points (
dict[str, torch.Tensor]，可选) — 用作解码器查询的张量字典。解码器将这些查询映射到模型的潜在表示。用于下采样解码，例如仅解码某些图像块。 - head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]之间：- 1 表示头部**未被掩码**，
- 0 表示头部**已被掩码**。
- output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵损失）。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。
返回
transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或 torch.FloatTensor 的元组 (如果传入 return_dict=False 或 config.return_dict=False 时)，包含根据配置 (PerceiverConfig) 和输入而变化的各种元素。
-
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=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 之后，用于计算交叉注意力头中的加权平均。
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]