Transformers documentation
Perceiver
该模型于 2021-07-30 在 HF papers 上发布，并于 2021-12-08 贡献给 Hugging Face Transformers。
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 的计算复杂度与输入和输出的大小呈线性关系，且大部分处理发生在潜在空间中，这使得我们能够处理比标准 Transformers 所能处理的规模大得多的输入和输出。这意味着，例如，Perceiver IO 可以直接使用字节而非分词后的输入，执行 BERT 风格的掩码语言建模。
该论文的摘要如下：
近期提出的 Perceiver 模型在多个领域（图像、音频、多模态、点云）中取得了良好的效果，同时其计算量和内存占用随输入规模线性增长。虽然 Perceiver 支持多种类型的输入，但它只能生成非常简单的输出，例如类别分数。Perceiver IO 通过灵活地查询模型的潜在空间来生成任意大小和语义的输出，从而克服了这一限制，同时保留了原模型令人满意的特性。Perceiver IO 依然将模型深度与数据规模解耦，并且随着数据规模线性扩展，但现在这种扩展同时针对输入和输出的规模。完整的 Perceiver IO 模型在具有高度结构化输出空间的任务上取得了强劲的结果，例如自然语言处理、视觉理解、StarCraft II 以及多任务和跨模态领域。作为亮点，Perceiver IO 在 GLUE 语言基准测试上达到了与基于 Transformer 的 BERT 基线相当的性能，且无需对输入进行分词；此外，它在 Sintel 光流估计任务上达到了最先进的性能。
以下是 Perceiver 工作原理的简要说明：
Transformer 自注意力机制的主要问题在于，其时间和内存需求随序列长度呈二次方增长。因此，BERT 和 RoBERTa 等模型的最大序列长度被限制为 512 个 token。Perceiver 旨在解决这一问题：它不对输入执行自注意力，而是对一组潜在变量执行自注意力，并仅将输入用于交叉注意力。这样一来，时间和内存需求不再取决于输入的长度，因为使用的是固定数量的潜在变量，例如 256 或 512。这些潜在变量经过随机初始化后，通过反向传播进行端到端训练。
在内部，PerceiverModel 会创建 latents，它是一个形状为 (batch_size, num_latents, d_latents) 的张量。必须向模型提供 inputs（可以是文本、图像、音频，等等！），模型将使用这些输入与 latents 执行交叉注意力。Perceiver 编码器的输出是一个形状相同的张量。随后，类似于 BERT，可以将 latents 的最后隐藏状态沿序列维度求平均，以将其转换为分类 logits，并在其上放置一个线性层，将 d_latents 投影到 num_labels。
这正是原始 Perceiver 论文的核心思想。然而，它只能输出分类 logits。在后续工作 PerceiverIO 中，他们将其进行了泛化，使模型能够生成任意大小的输出。你可能会问，这是如何实现的？其思路其实相对简单：定义任意大小的输出，然后应用交叉注意力机制，以这些输出作为查询（queries），以 latents 的最后隐藏状态作为键（keys）和值（values）。
假设我们想使用 Perceiver 执行掩码语言建模（BERT 风格）。由于 Perceiver 的输入长度不会影响自注意力层的计算时间，我们可以直接提供原始字节，向模型输入长度为 2048 的 inputs。如果现在对其中某些 2048 个 token 进行掩码，可以将 outputs 定义为形状 (batch_size, 2048, 768)。接下来，使用 latents 的最终隐藏状态执行交叉注意力，以更新 outputs 张量。交叉注意力之后，我们仍然得到一个形状为 (batch_size, 2048, 768) 的张量。然后，可以在其上方放置一个常规的语言建模头，将最后一个维度投影到模型的词汇表大小，即创建形状为 (batch_size, 2048, 262) 的 logits（因为 Perceiver 使用大小为 262 的字节 ID 词汇表）。
Perceiver IO architecture. Taken from the original paper 由于 PyTorch 中的一个 bug，Perceiver 无法与
torch.nn.DataParallel配合使用，请参阅 issue #36035
资源
- 快速上手 Perceiver 的最佳方式是查看教程笔记本。
- 如需全面了解该模型的工作原理及其在库中的实现方式，请参阅博客文章。请注意，库中提供的模型仅展示了使用 Perceiver 的部分示例。Perceiver 还有更多应用场景，包括问答、命名实体识别、目标检测、音频分类、视频分类等。
- 文本分类任务指南
- 掩码语言建模任务指南
- 图像分类任务指南
Perceiver 特定输出
类 transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput
< source >( logits: typing.Optional[torch.Tensor] = Nonelast_hidden_state: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
参数
- logits (
torch.Tensor，形状为(batch_size, num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。 - last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple[torch.Tensor], 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组，包含torch.Tensor(嵌入层输出（如果模型有嵌入层）+ 每层输出的张量，形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple[torch.Tensor], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple[torch.Tensor], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
Perceiver 基础模型输出的基类，可能包含隐藏状态、注意力机制和交叉注意力。
类 transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput
< source >( logits: typing.Optional[torch.Tensor] = Nonecross_attentions: tuple[torch.Tensor] | None = None )
参数
- logits（形状为
(batch_size, num_labels)的torch.Tensor）— 基础解码器的输出。 - cross_attentions (
tuple[torch.Tensor], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
Perceiver 解码器输出的基类，可能包含交叉注意力。
class transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 掩码语言建模（MLM）损失。 - logits (
torch.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - hidden_states (
tuple[torch.Tensor], 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组，包含torch.Tensor(嵌入层输出（如果模型有嵌入层）+ 每层输出的张量，形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple[torch.Tensor], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple[torch.Tensor], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
Perceiver 掩码语言模型输出的基类。
class transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。 - hidden_states (
tuple[torch.Tensor], 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组，包含torch.Tensor(嵌入层输出（如果模型有嵌入层）+ 每层输出的张量，形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple[torch.Tensor], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple[torch.Tensor], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
Perceiver 的序列/图像分类模型、光流以及多模态自编码输出的基类。
PerceiverConfig
class transformers.PerceiverConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_latents: int = 256d_latents: int = 1280d_model: int = 768num_blocks: int = 1num_self_attends_per_block: int = 26num_self_attention_heads: int = 8num_cross_attention_heads: int = 8qk_channels: int | None = Nonev_channels: int | None = Nonecross_attention_shape_for_attention: str = 'kv'self_attention_widening_factor: int = 1cross_attention_widening_factor: int = 1hidden_act: str = 'gelu'attention_probs_dropout_prob: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-12use_query_residual: bool = Truevocab_size: int = 262max_position_embeddings: int = 2048image_size: int | list[int] | tuple[int, int] = 56train_size: list[int] | tuple[int, ...] = (368, 496)num_frames: int = 16audio_samples_per_frame: int = 1920samples_per_patch: int = 16output_shape: list[int] | tuple[int, ...] = (1, 16, 224, 224)output_num_channels: int = 512_label_trainable_num_channels: int = 1024 )
参数
- num_latents (
int，可选，默认为 256) — 潜变量的数量。 - d_latents (
int，可选，默认为 1280) — 潜在嵌入的维度。 - d_model (
int，可选，默认为768) — 编码器层和池化层的维度大小。 - 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") — 在编码器的交叉注意力层中对 queries 和 keys 进行降采样时所使用的维度。 - self_attention_widening_factor (
int，可选，默认为 1) — Transformer 编码器中交叉注意力层的前馈层维度。 - cross_attention_widening_factor (
int，可选，默认为 1) — Transformer 编码器中自注意力层的前馈层维度。 - hidden_act (
str，可选，默认为gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - attention_probs_dropout_prob (
Union[float, int]，可选，默认为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) — 模型的词汇表大小。定义了input_ids可以表示的不同 token 的数量。 - max_position_embeddings (
int，可选，默认为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) — 在为多模态自编码模型预处理音频时，每个 patch 包含的音频采样数。 - output_shape (
list[int]，可选，默认为[1, 16, 224, 224]) — 多模态自编码模型的视频解码器查询的输出形状 (batch_size, num_frames, height, width)。此形状不包含通道维度。 - output_num_channels (
int, 可选，默认为 512) — 每个模态解码器的输出通道数。
这是用于存储 PerceiverModel 配置的类。它根据指定的参数实例化 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。在构建包含特殊标记的序列时，序列末尾使用的并不是这个标记。 实际使用的是
sep_token。 - mask_token (
str，可选，默认为"[MASK]") — MASK 标记，适用于掩码语言建模。 - cls_token (
str，可选，默认为"[CLS]") — CLS 标记（在词表中保留，但实际未使用）。 - sep_token (
str，可选，默认为"[SEP]") — 分隔符 token，用于将两个序列组合成一个序列时。
构建一个 Perceiver 分词器。Perceiver 直接使用原始字节的 utf-8 编码。
该分词器继承自 PreTrainedTokenizer，其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。
__call__
< source >( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**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（以消除与序列批次的歧义）。 - tokenizer_kwargs (
dict[str, Any], 可选) — 传递给 tokenizer 的额外 kwargs。这些 kwargs 将与显式参数及其他 kwargs 合并，其中显式参数具有更高的优先级。 - 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指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。'only_first'：截断至由参数max_length指定的最大长度，或者在未提供该参数时，截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断其中的第一个序列。'only_second'：截断至由参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。仅当提供了一对序列（或一批序列对）时，才会截断其中的第二个序列。False或'do_not_truncate'（默认值）：不进行截断（即，可以输出序列长度大于模型最大可接受输入大小的批次）。
- max_length (
int, 可选) — 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 None，则当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（如 XLNet），则禁用截断/填充到最大长度的功能。如果未设置或设置为
None，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。 - stride (
int，可选，默认为 0) — 如果与max_length一起设置为某个数值，则当return_overflowing_tokens=True时，返回的溢出 token 将包含截断序列末尾的若干 token，以在截断序列和溢出序列之间提供一定的重叠。此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool，可选，默认为False) — 输入是否已经预先分词（例如，已拆分为单词）。如果设置为True，分词器将假设输入已经拆分为单词（例如，通过按空白字符拆分），然后对其进行分词。这对于命名实体识别（NER）或 token 分类非常有用。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充为所提供值的倍数。需要启用padding。 这对于在计算能力为>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。 - padding_side (
str, 可选) — 模型应应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。 默认值取自同名的类属性。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, 可选) — 是否返回 token type ID。如果保持默认值，将根据特定分词器的默认设置返回 token type ID，该设置由return_outputs属性定义。 - return_attention_mask (
bool, 可选) — 是否返回注意力掩码。如果保持默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由return_outputs属性定义。 - return_overflowing_tokens (
bool，可选，默认为False) — 是否返回溢出的 token 序列。如果提供了输入 id 的序列对（或序列对批次），且truncation_strategy = longest_first或True，则会抛出错误，而不是返回溢出的 token。 - return_special_tokens_mask (
bool，可选，默认为False) — 是否返回特殊 token 掩码信息。 - return_offsets_mapping (
bool, 可选, 默认为False) — 是否返回(char_start, char_end)每个 token 的。此功能仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用。如果使用 Python 分词器，此方法将抛出
NotImplementedError。 - return_length (
bool，可选，默认为False) — 是否返回编码后输入的长度。 - verbose (
bool，可选，默认为True) — 是否打印更多信息和警告。 - **kwargs — 传递给
self.tokenize()方法
返回值
一个包含以下字段的 BatchEncoding：
-
input_ids — 要输入模型的 token id 列表。
-
token_type_ids — 要输入模型的 token 类型 ID 列表（当
return_token_type_ids=True或self.model_input_names中包含 “token_type_ids” 时）。 -
attention_mask — 索引列表，指定模型应关注哪些 token（当
return_attention_mask=True或 “attention_mask” 位于self.model_input_names中时）。 -
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 表示添加的特殊标记，0 表示常规序列标记（当
add_special_tokens=True且return_special_tokens_mask=True时）。 -
length — 输入的长度（当
return_length=True时）
用于对一条或多条序列，或一对或多对序列进行分词并准备输入模型的主要方法。
PerceiverImageProcessor
class transformers.PerceiverImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
参数
- do_convert_rgb (
bool，kwargs，可选) — 是否将图像转换为 RGB。 - do_resize (
bool，kwargs，可选，默认为True) — 是否调整图像大小。 - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]，kwargs，默认为{'height' -- 224, 'width': 224})： 描述输入到模型的最大尺寸。 - default_to_square (
bool，kwargs，可选，默认为True) — 当 size 为 int 时，是否在调整大小时默认使用正方形图像。 - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs，默认为{'height' -- 256, 'width': 256})： 应用center_crop后输出图像的尺寸。 - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs，默认为3) — 如果调整图像大小，则使用的重采样滤波器。它可以是枚举PILImageResampling中的一个值。仅当do_resize设置为True时才会生效。 - do_rescale (
bool，kwargs，可选，默认为True) — 是否对图像进行重新缩放。 - rescale_factor (
float，kwargs，可选，默认为0.00392156862745098) — 当do_rescale设置为True时，用于对图像进行缩放的缩放因子。 - do_normalize (
bool，kwargs，可选，默认为True) — 是否对图像进行归一化。 - image_mean (
Union[float, list[float], tuple[float, ...]]，kwargs，可选，默认为[0.485, 0.456, 0.406]) — 用于归一化的图像均值。仅当do_normalize设置为True时生效。 - image_std (
Union[float, list[float], tuple[float, ...]]，kwargs，可选，默认为[0.229, 0.224, 0.225]) — 用于归一化的图像标准差。仅当do_normalize设置为True时生效。 - do_pad (
bool, kwargs, 可选) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。 - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 用于填充图像的{"height": int, "width" int}尺寸。必须大于为预处理提供的任何图像尺寸。如果未提供pad_size，图像将被填充到批次中最大的高度和宽度。仅在do_pad=True.时应用。 - do_center_crop (
bool，kwargs，可选，默认为True) — 是否对图像进行中心裁剪。 - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 仅支持ChannelDimension.FIRST。为兼容旧版处理器而添加。 - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像采用 (num_channels, height, width) 格式。"channels_last"或ChannelDimension.LAST：图像采用 (height, width, num_channels) 格式。"none"或ChannelDimension.NONE：图像为 (height, width) 格式。
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。 - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为'pt'，则返回堆叠的张量，否则返回张量列表。 - disable_grouping (
bool，kwargs，可选) — 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。 如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int，kwargs，可选) — 输入中每张图片所使用的图像 token 数量。 为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。
构建一个 PerceiverImageProcessor 图像处理器。
预处理
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~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。 - image_like_kwargs (
dict[str, Any], 可选) — 用于额外图像类输入的开发者标志，这些输入也将被预处理。仅在以关键字参数传递输入不起作用时使用此标志。例如，preprocess(images, masks=masks)是首选方式，但对于某些模型会导致参数优先级问题。在这种情况下，可以改用preprocess(images, image_like_inputs={"masks": masks})。 - do_convert_rgb (
bool，kwargs，可选) — 是否将图像转换为 RGB。 - do_resize (
bool，kwargs，可选) — 是否调整图像大小。 - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 描述模型的最大输入维度。 - default_to_square (
bool, kwargs, 可选) — 当 size 为整数时，是否在调整大小时默认使用正方形图像。 - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 应用center_crop后输出图像的尺寸。 - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — 如果调整图像大小，则使用的重采样滤波器。可以是枚举PILImageResampling中的一个值。仅当do_resize设置为True时生效。 - do_rescale (
bool，kwargs，可选) — 是否对图像进行重新缩放。 - rescale_factor (
float, kwargs, 可选) — 如果do_rescale设置为True，则用于对图像进行缩放的缩放因子。 - do_normalize (
bool，kwargs，可选) — 是否对图像进行归一化。 - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, 可选) — 用于归一化的图像均值。仅当do_normalize设置为True时生效。 - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, 可选) — 用于归一化的图像标准差。仅当do_normalize设置为True时生效。 - do_pad (
bool, kwargs, 可选) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。 - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 用于填充图像的{"height": int, "width" int}尺寸。必须大于为预处理提供的任何图像尺寸。如果未提供pad_size，图像将被填充到批次中最大的高度和宽度。仅在do_pad=True.时应用。 - do_center_crop (
bool，kwargs，可选) — 是否对图像进行中心裁剪。 - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 仅支持ChannelDimension.FIRST。为兼容旧版处理器而添加。 - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像采用 (num_channels, height, width) 格式。"channels_last"或ChannelDimension.LAST：图像采用 (height, width, num_channels) 格式。"none"或ChannelDimension.NONE：图像为 (height, width) 格式。
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。 - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为'pt'，则返回堆叠的张量，否则返回张量列表。 - disable_grouping (
bool，kwargs，可选) — 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。 如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int，kwargs，可选) — 输入中每张图片所使用的图像 token 数量。 为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。
返回值
~image_processing_base.BatchFeature
- data (
dict) — 由 call 方法返回的列表/数组/张量字典（如 ‘pixel_values’ 等）。 - tensor_type (
Union[None, str, TensorType], 可选) — 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。
预处理一张图像或一批图像。
PerceiverImageProcessorPil
class transformers.PerceiverImageProcessorPil
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
参数
- do_convert_rgb (
bool，kwargs，可选) — 是否将图像转换为 RGB。 - do_resize (
bool，kwargs，可选，默认为True) — 是否调整图像大小。 - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]，kwargs，默认为{'height' -- 224, 'width': 224})： 描述输入到模型的最大尺寸。 - default_to_square (
bool，kwargs，可选，默认为True) — 当 size 为 int 时，是否在调整大小时默认使用正方形图像。 - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs，默认为{'height' -- 256, 'width': 256})： 应用center_crop后输出图像的尺寸。 - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs，默认为3) — 如果调整图像大小，则使用的重采样滤波器。它可以是枚举PILImageResampling中的一个值。仅当do_resize设置为True时才会生效。 - do_rescale (
bool，kwargs，可选，默认为True) — 是否对图像进行重新缩放。 - rescale_factor (
float，kwargs，可选，默认为0.00392156862745098) — 当do_rescale设置为True时，用于对图像进行缩放的缩放因子。 - do_normalize (
bool，kwargs，可选，默认为True) — 是否对图像进行归一化。 - image_mean (
Union[float, list[float], tuple[float, ...]]，kwargs，可选，默认为[0.485, 0.456, 0.406]) — 用于归一化的图像均值。仅当do_normalize设置为True时生效。 - image_std (
Union[float, list[float], tuple[float, ...]]，kwargs，可选，默认为[0.229, 0.224, 0.225]) — 用于归一化的图像标准差。仅当do_normalize设置为True时生效。 - do_pad (
bool, kwargs, 可选) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。 - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 用于填充图像的{"height": int, "width" int}尺寸。必须大于为预处理提供的任何图像尺寸。如果未提供pad_size，图像将被填充到批次中最大的高度和宽度。仅在do_pad=True.时应用。 - do_center_crop (
bool，kwargs，可选，默认为True) — 是否对图像进行中心裁剪。 - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 仅支持ChannelDimension.FIRST。为兼容旧版处理器而添加。 - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像采用 (num_channels, height, width) 格式。"channels_last"或ChannelDimension.LAST：图像采用 (height, width, num_channels) 格式。"none"或ChannelDimension.NONE：图像为 (height, width) 格式。
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。 - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为'pt'，则返回堆叠的张量，否则返回张量列表。 - disable_grouping (
bool，kwargs，可选) — 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。 如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int，kwargs，可选) — 输入中每张图片所使用的图像 token 数量。 为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。
构建一个 PerceiverImageProcessor 图像处理器。
预处理
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~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。 - image_like_kwargs (
dict[str, Any], 可选) — 用于额外图像类输入的开发者标志，这些输入也将被预处理。仅在以关键字参数传递输入不起作用时使用此标志。例如，preprocess(images, masks=masks)是首选方式，但对于某些模型会导致参数优先级问题。在这种情况下，可以改用preprocess(images, image_like_inputs={"masks": masks})。 - do_convert_rgb (
bool，kwargs，可选) — 是否将图像转换为 RGB。 - do_resize (
bool，kwargs，可选) — 是否调整图像大小。 - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 描述模型的最大输入维度。 - default_to_square (
bool, kwargs, 可选) — 当 size 为整数时，是否在调整大小时默认使用正方形图像。 - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 应用center_crop后输出图像的尺寸。 - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — 如果调整图像大小，则使用的重采样滤波器。可以是枚举PILImageResampling中的一个值。仅当do_resize设置为True时生效。 - do_rescale (
bool，kwargs，可选) — 是否对图像进行重新缩放。 - rescale_factor (
float, kwargs, 可选) — 如果do_rescale设置为True，则用于对图像进行缩放的缩放因子。 - do_normalize (
bool，kwargs，可选) — 是否对图像进行归一化。 - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, 可选) — 用于归一化的图像均值。仅当do_normalize设置为True时生效。 - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, 可选) — 用于归一化的图像标准差。仅当do_normalize设置为True时生效。 - do_pad (
bool, kwargs, 可选) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。 - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 用于填充图像的{"height": int, "width" int}尺寸。必须大于为预处理提供的任何图像尺寸。如果未提供pad_size，图像将被填充到批次中最大的高度和宽度。仅在do_pad=True.时应用。 - do_center_crop (
bool，kwargs，可选) — 是否对图像进行中心裁剪。 - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 仅支持ChannelDimension.FIRST。为兼容旧版处理器而添加。 - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像采用 (num_channels, height, width) 格式。"channels_last"或ChannelDimension.LAST：图像采用 (height, width, num_channels) 格式。"none"或ChannelDimension.NONE：图像为 (height, width) 格式。
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。 - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为'pt'，则返回堆叠的张量，否则返回张量列表。 - disable_grouping (
bool，kwargs，可选) — 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。 如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int，kwargs，可选) — 输入中每张图片所使用的图像 token 数量。 为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。
返回值
~image_processing_base.BatchFeature
- data (
dict) — 由 call 方法返回的列表/数组/张量字典（如 ‘pixel_values’ 等）。 - tensor_type (
Union[None, str, TensorType], 可选) — 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。
预处理一张图像或一批图像。
PerceiverTextPreprocessor
类 transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor
< source >( config: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型配置。
用于 Perceiver Encoder 的文本预处理。可用于嵌入 inputs 并添加位置编码。
嵌入的维度由配置中的 d_model 属性决定。
PerceiverImagePreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor
< source >( configprep_type = 'conv'spatial_downsample: int = 4temporal_downsample: int = 1position_encoding_type: str = 'fourier'in_channels: int = 3out_channels: int = 64conv_after_patching: bool = Falseconv_after_patching_in_channels: int = 54conv2d_use_batchnorm: bool = Trueconcat_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 Encoder 的图像预处理。
注意：out_channels 参数指的是卷积层的输出通道数，前提是 prep_type 被设置为 “conv1x1” 或 “conv”。如果添加了绝对位置嵌入，则必须确保位置编码 kwargs 中的 num_channels 与 out_channels 相等。
PerceiverOneHotPreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor
< source >( config: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型配置。
Perceiver Encoder 的 One-hot 预处理器。可用于为输入添加一个虚拟的索引维度。
PerceiverAudioPreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor
< source >( configprep_type: str = 'patches'samples_per_patch: int = 96position_encoding_type: str = 'fourier'concat_or_add_pos: str = 'concat'out_channels = 64project_pos_dim = -1**position_encoding_kwargs )
参数
- config ([PerceiverConfig]) — 模型配置。
- prep_type (
str，可选，默认为"patches") — 要使用的预处理器类型。仅支持 “patches”。 - samples_per_patch (
int，可选，默认为 96) — 每个 patch 的样本数量。 - position_encoding_type (
str, 可选，默认为"fourier") — 要使用的位置编码类型。可以是 “trainable” 或 “fourier”。 - concat_or_add_pos (
str，可选，默认为"concat") — 如何将位置编码与输入进行拼接。可以是“concat”或“add”。 - out_channels (
int，可选，默认为 64) — 输出中的通道数。 - project_pos_dim (
int，可选，默认值为 -1) — 位置编码要投影到的维度。如果为 -1，则不应用投影。 - **position_encoding_kwargs (
Dict, 可选) — 位置编码的关键字参数。
用于 Perceiver Encoder 的音频预处理。
PerceiverMultimodalPreprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor
< source >( modalities: collections.abc.Mapping[str, collections.abc.Callable[..., tuple[torch.Tensor, typing.Optional[torch.Tensor], torch.Tensor]]]mask_probs: collections.abc.Mapping[str, float] | None = Nonemin_padding_size: int = 2 )
Perceiver Encoder 的多模态预处理。
每种模态的输入经过预处理后，会使用可训练的位置嵌入进行填充，使其具有相同的通道数。
PerceiverProjectionDecoder
class transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder
< source >( config )
参数
- config (PerceiverConfig) — 模型配置。
基线投影解码器（无交叉注意力）。
PerceiverBasicDecoder
类 transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder
< source >( config: PerceiverConfigoutput_num_channels: intposition_encoding_type: str | None = 'trainable'output_index_dims: int | None = Nonenum_channels: int | None = 128subsampled_index_dims: int | None = Noneqk_channels: int | None = Nonev_channels: int | None = Nonenum_heads: int | None = 1widening_factor: int | None = 1use_query_residual: bool | None = Falseconcat_preprocessed_input: bool | None = Falsefinal_project: bool | None = Trueposition_encoding_only: bool | None = False**position_encoding_kwargs )
参数
- config ([PerceiverConfig]) — 模型配置。
- output_num_channels (
int, 可选) — 输出的通道数。仅当 final_project 设置为True时才会使用。 - position_encoding_type (
str, 可选，默认为 “trainable”) — 要使用的位置编码类型。可以是 “trainable”、“fourier” 或 “none”。 - output_index_dims (
int, 可选) — 输出查询的维度数量。如果 ‘position_encoding_type’ == ‘none’，则忽略此参数。 - num_channels (
int, 可选，默认为 128) — 解码器查询的通道数。如果 ‘position_encoding_type’ == ‘none’，则忽略此参数。 - qk_channels (
int, 可选) — 交叉注意力层中查询和键的通道数。 - v_channels (
int，可选) — 交叉注意力层中值的通道数。 - num_heads (
int，可选，默认为 1) — 交叉注意力层中注意力头的数量。 - widening_factor (
int，可选，默认为 1) — 交叉注意力层的扩展因子。 - use_query_residual (
bool，可选，默认为False) — 是否使用 query 与交叉注意力层输出之间的残差连接。 - concat_preprocessed_input (
bool，可选，默认为False) — 是否将预处理后的输入与查询拼接。 - final_project (
bool，可选，默认为True) — 是否将交叉注意力层的输出投影到目标维度。 - position_encoding_only (
bool，可选，默认为False) — 是否仅使用此类来定义输出查询。
基于交叉注意力的解码器。此类可用于通过交叉注意力操作解码潜变量的最终隐藏状态，其中潜变量生成键和值。
该类的输出形状取决于如何定义输出查询（也称为解码器查询）。
PerceiverClassificationDecoder
class transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder
< source >( config**decoder_kwargs )
参数
- config (PerceiverConfig) — 模型配置。
基于交叉注意力的分类解码器。PerceiverBasicDecoder 的轻量级封装，用于输出 logit。
它将 Perceiver 编码器输出的形状为 (batch_size, num_latents, d_latents) 的张量，转换为形状为
(batch_size, num_labels) 的张量。查询（queries）的形状为 (batch_size, 1, num_labels)。
PerceiverOpticalFlowDecoder
类 transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder
< source >( configoutput_image_shapeoutput_num_channels = 2rescale_factor = 100.0**decoder_kwargs )
基于交叉注意力的光流解码器。
PerceiverBasicVideoAutoencodingDecoder
class transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder
< source >( config: PerceiverConfigoutput_shape: list[int]position_encoding_type: str**decoder_kwargs )
基于交叉注意力的视频自编码解码器。[PerceiverBasicDecoder] 的轻量级封装，包含视频重塑逻辑。
PerceiverMultimodalDecoder
class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder
< source >( config: PerceiverConfigmodalities: dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder]num_outputs: intoutput_num_channels: intmin_padding_size: int | None = 2subsampled_index_dims: dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder] | None = None**decoder_kwargs )
参数
- config ([PerceiverConfig]) — 模型配置。
- modalities (
dict[str, PerceiverAbstractDecoder]) — 一个字典，将模态名称映射到该模态对应的解码器。 - num_outputs (
int) — 解码器的输出数量。 - output_num_channels (
int) — 输出中的通道数。 - min_padding_size (
int，可选，默认为 2) — 所有模态的最小填充大小。最终输出的 num_channels 将等于所有模态中的最大通道数加上 min_padding_size。 - subsampled_index_dims (
dict[str, PerceiverAbstractDecoder]，可选) — 一个字典，将模态名称映射到该模态的解码器查询所使用的降采样索引维度。
通过组合单模态解码器实现多模态解码。构造函数的 modalities 参数是一个字典，将模态名称映射到该模态对应的解码器。该解码器将用于构建对应模态的查询。特定模态的查询会使用可训练的模态特定参数进行填充，随后沿时间维度进行拼接。
接下来，所有模态之间共享一个交叉注意力操作。
PerceiverProjectionPostprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor
< source >( in_channels: intout_channels: int )
Perceiver 的投影后处理。可用于将解码器输出的通道投影到更低的维度。
PerceiverAudioPostprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor
< source >( config: PerceiverConfigin_channels: intpostproc_type: str = 'patches' )
Perceiver 的音频后处理。可用于将解码器输出转换为音频特征。
PerceiverClassificationPostprocessor
class transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor
< source >( config: PerceiverConfigin_channels: int )
Perceiver 的分类后处理。可用于将解码器输出转换为分类 logits。
PerceiverMultimodalPostprocessor
类 transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor
< source >( modalities: collections.abc.Mapping[str, collections.abc.Callable[..., typing.Any]]input_is_dict: bool = False )
Perceiver 的多模态后处理。可用于将特定模态的后处理器组合为单一的后处理器。
PerceiverModel
class transformers.PerceiverModel
< source >( config: PerceiverConfigdecoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = Noneinput_preprocessor: collections.abc.Callable[..., tuple[torch.Tensor, typing.Optional[torch.Tensor], torch.Tensor]] = Noneoutput_postprocessor: collections.abc.Callable[..., typing.Any] = None )
参数
- config (PerceiverConfig) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- decoder (
PerceiverDecoder，可选) — 将潜在表示转换为任务预测的解码器模块。 - input_preprocessor (
PreprocessorType，可选) — 用于将原始输入编码为模型张量的预处理器。 - output_postprocessor (
PostprocessorType，可选) — 将模型输出转换为最终预测的后处理器。
Perceiver：一种可扩展的、完全基于注意力的架构。
请注意，通过在模型的前向传播中将
interpolate_pos_encoding设置为True，可以将 Perceiver 微调至比其训练数据更高分辨率的图像。这会将预训练的位置嵌入插值到更高分辨率。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( inputs: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonesubsampled_output_points: dict[str, torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Noneinterpolate_pos_encoding: bool = Falsereturn_dict: bool | None = None**kwargs ) → PerceiverModelOutput or tuple(torch.Tensor)
参数
- inputs (
torch.Tensor) — 输入到 perceiver 的数据。可以是任意类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- subsampled_output_points (
dict[str, torch.Tensor], 可选) — 用作解码器查询的张量字典。解码器会将这些查询映射到模型的潜在表示。用于子采样解码，例如仅解码某些图像块时。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - interpolate_pos_encoding (
bool，可选，默认为False) — 是否对预训练的位置编码进行插值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
PerceiverModelOutput 或 tuple(torch.Tensor)
一个 PerceiverModelOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（PerceiverConfig）和输入。
PerceiverModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
logits（形状为
(batch_size, num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选）— 模型最后一层输出的隐藏状态序列。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
示例：
>>> from transformers import PerceiverConfig, PerceiverTokenizer, PerceiverImageProcessor, PerceiverModel
>>> from transformers.models.perceiver.modeling_perceiver import (
... PerceiverTextPreprocessor,
... PerceiverImagePreprocessor,
... PerceiverClassificationDecoder,
... )
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> 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"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> 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
< source >( config: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Perceiver 用于掩码语言建模的示例用法。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Noneinput_ids: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverMaskedLMOutput or tuple(torch.Tensor)
参数
- inputs (
torch.Tensor, 可选) — 输入到 perceiver 的数据。可以是任意类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 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的 token 将被忽略（即被掩码），损失仅针对标签在[0, ..., config.vocab_size]范围内的 token 进行计算。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - input_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
返回值
PerceiverMaskedLMOutput 或 tuple(torch.Tensor)
一个 PerceiverMaskedLMOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（PerceiverConfig）和输入。
PerceiverForMaskedLM 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 掩码语言建模（MLM）损失。logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
示例：
>>> 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
< source >( config: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Perceiver 用于文本分类的示例用法。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Noneinput_ids: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
参数
- inputs (
torch.Tensor, 可选) — 输入到 perceiver 的数据。可以是任意类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 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), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
返回值
PerceiverClassifierOutput 或 tuple(torch.Tensor)
一个 PerceiverClassifierOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（PerceiverConfig）和输入。
PerceiverForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
示例：
>>> 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
< source >( config: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Perceiver 在图像分类任务（例如 ImageNet）中的使用示例。
该模型使用学习得到的位置嵌入。换言之，该模型未获得任何关于图像结构的特权信息。如论文所示，该模型在 ImageNet 上可达到 72.7 的 top-1 准确率。
PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor（其中 prep_type="conv1x1"）对输入图像进行预处理，并使用 PerceiverClassificationDecoder 将 PerceiverModel 的潜在表示解码为分类 logits。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool = Falsereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
参数
- inputs (
torch.Tensor, 可选) — 输入到 perceiver 的数据。可以是任意类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - labels（形状为
(batch_size,)的torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[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)，可选) — 对应输入图像的张量。可以使用 PerceiverImageProcessor 获取像素值。有关详细信息，请参阅 PerceiverImageProcessor.call()（processor_class使用 PerceiverImageProcessor 处理图像）。
返回值
PerceiverClassifierOutput 或 tuple(torch.Tensor)
一个 PerceiverClassifierOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（PerceiverConfig）和输入。
PerceiverForImageClassificationLearned 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
示例：
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationLearned
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> 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: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Perceiver 在图像分类任务（例如 ImageNet）中的使用示例。
该模型使用固定的 2D 傅里叶位置嵌入。如论文所示，该模型在 ImageNet 上可达到 79.0 的 top-1 准确率，在大规模数据集（即 JFT）上进行预训练后可达到 84.5。
PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor（设置 prep_type="pixels"）对输入图像进行预处理，并使用 PerceiverClassificationDecoder 将 PerceiverModel 的潜在表示解码为分类 logits。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
参数
- inputs (
torch.Tensor, 可选) — 输入到 perceiver 的数据。可以是任意类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - labels（形状为
(batch_size,)的torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[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)，可选) — 对应输入图像的张量。可以使用 PerceiverImageProcessor 获取像素值。有关详细信息，请参阅 PerceiverImageProcessor.call()（processor_class使用 PerceiverImageProcessor 处理图像）。
返回值
PerceiverClassifierOutput 或 tuple(torch.Tensor)
一个 PerceiverClassifierOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（PerceiverConfig）和输入。
PerceiverForImageClassificationFourier 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
示例：
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationFourier
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> 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: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Perceiver 在图像分类任务（例如 ImageNet）中的使用示例。
该模型使用 2D conv+maxpool 预处理网络。如论文所示，该模型在 ImageNet 上可达到 82.1 的 top-1 准确率。
PerceiverForImageClassificationLearned 使用 PerceiverImagePreprocessor（其中 prep_type="conv"）对输入图像进行预处理，并使用 PerceiverClassificationDecoder 将 PerceiverModel 的潜在表示解码为分类 logits。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
参数
- inputs (
torch.Tensor, 可选) — 输入到 perceiver 的数据。可以是任意类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - labels（形状为
(batch_size,)的torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[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)，可选) — 对应输入图像的张量。可以使用 PerceiverImageProcessor 获取像素值。有关详细信息，请参阅 PerceiverImageProcessor.call()（processor_class使用 PerceiverImageProcessor 处理图像）。
返回值
PerceiverClassifierOutput 或 tuple(torch.Tensor)
一个 PerceiverClassifierOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（PerceiverConfig）和输入。
PerceiverForImageClassificationConvProcessing 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
示例：
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationConvProcessing
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> 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: PerceiverConfig )
参数
- config (PerceiverConfig) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Perceiver 在光流任务（例如 Sintel 和 KITTI）中的示例用法。PerceiverForOpticalFlow 使用 PerceiverImagePreprocessor（设置 prep_type=“patches”）对输入图像进行预处理，并使用 PerceiverOpticalFlowDecoder 解码 PerceiverModel 的潜在表示。
作为输入，将相邻的 2 帧沿通道维度拼接，并提取每个像素周围的 3 x 3 补丁（导致每个像素有 3 x 3 x 3 x 2 = 54 个值）。使用固定的傅里叶位置编码来编码补丁中每个像素的位置。接下来，应用 Perceiver 编码器。为了进行解码，使用与输入相同的编码来查询潜在表示。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
参数
- inputs (
torch.Tensor, 可选) — 输入到 perceiver 的数据。可以是任意类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - labels（形状为
(batch_size,)的torch.LongTensor，可选） — 用于计算光流损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
PerceiverClassifierOutput 或 tuple(torch.Tensor)
一个 PerceiverClassifierOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（PerceiverConfig）和输入。
PerceiverForOpticalFlow 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
示例：
>>> 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 对三种模态（图像、音频和类别标签）进行预处理。该预处理器使用针对各模态的专用预处理器分别对每种模态进行预处理，随后将它们拼接在一起。通过可训练的位置嵌入，将每种模态填充至相同的通道数，从而实现在时间维度上的拼接。接下来，应用 Perceiver 编码器。
PerceiverMultimodalDecoder 用于解码 PerceiverModel 的潜在表示。该解码器使用每种模态特定的解码器来构建查询。解码器查询基于预处理后的输入创建。然而，在单次前向传播中对整个视频进行自编码在计算上是不可行的，因此仅使用部分解码器查询与潜在表示进行交叉注意力。这由每种模态的降采样索引决定，这些索引可以作为 PerceiverForMultimodalAutoencoding 前向传播的额外输入提供。
PerceiverMultimodalDecoder 还会将不同模态的解码器查询填充至相同的通道数，以便沿时间维度进行拼接。随后，使用 PerceiverModel 的潜在表示执行交叉注意力。
最后，~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor 用于将该张量转换为实际的视频。它首先将输出拆分为不同的模态，然后对每个模态应用相应的后处理器。
请注意，在评估过程中对分类标签进行掩码处理（即仅为“label”模态提供一个全零张量），该自编码模型即可用作 Kinetics 700 视频分类器。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonesubsampled_output_points: dict[str, torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
参数
- inputs (
torch.Tensor, 可选) — 输入到 perceiver 的数据。可以是任意类型：图像、文本、音频、视频等。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- subsampled_output_points (
dict[str, torch.Tensor], 可选) — 用作解码器查询的张量字典。解码器会将这些查询映射到模型的潜在表示。用于子采样解码，例如仅解码某些图像块时。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - labels（形状为
(batch_size,)的torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵）。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
PerceiverClassifierOutput 或 tuple(torch.Tensor)
一个 PerceiverClassifierOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（PerceiverConfig）和输入。
PerceiverForMultimodalAutoencoding 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
示例：
>>> 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]