# 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](https://huggingface.co/papers/2107.14795) 中提出。 Perceiver IO 是 [Perceiver](https://huggingface.co/papers/2103.03206) 的泛化，除了处理任意输入外，还能处理任意输出。原始的 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](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverModel) 会创建潜变量（latents），其形状为 `(batch_size, num_latents, d_latents)` 的张量。需要向模型提供 `inputs`（可以是文本、图像、音频，等等！），模型将使用这些输入与潜变量执行交叉注意力。Perceiver 编码器的输出是一个形状相同的张量。随后，类似于 BERT，可以将潜变量的最后一层隐藏状态沿序列维度求平均，并在其上添加一个线性层，将 `d_latents` 投影到 `num_labels`，从而转换为分类 logits。 这正是原始 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 词汇表）。 drawing Perceiver IO 架构。摘自原始论文 该模型由 [nielsr](https://huggingface.co/nielsr) 贡献。原始代码可在[此处](https://github.com/deepmind/deepmind-research/tree/master/perceiver)找到。 由于 PyTorch 中的一个 bug，Perceiver **无法**与 `torch.nn.DataParallel` 配合使用，请参阅 [issue #36035](https://github.com/pytorch/pytorch/issues/36035) ## 资源 - 快速上手 Perceiver 的方法是查看[教程笔记本](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/Perceiver)。 - 如需完全了解该模型的工作原理，请参阅[博客文章](https://huggingface.co/blog/perceiver) is implemented in the library. Note that the models available in the library only showcase some examples of what you can do with the Perceiver. There are many more use cases, including question answering, named-entity recognition, object detection, audio classification, video classification, etc. - [文本分类任务指南](../tasks/sequence_classification) - [掩码语言建模任务指南](../tasks/masked_language_modeling) - [图像分类任务指南](../tasks/image_classification) ## Perceiver 特定输出[[transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput]] #### transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput(logits: typing.Optional[torch.Tensor] = None, last_hidden_state: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L53) **参数：** 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[[transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput(logits: typing.Optional[torch.Tensor] = None, cross_attentions: tuple[torch.Tensor] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L72) **参数：** logits (`torch.Tensor`，形状为 `(batch_size, num_labels)`)：基础解码器的输出。 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.PerceiverMaskedLMOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L88) **参数：** 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 掩码语言模型输出的基类。 #### transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L110) **参数：** loss (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回)：分类损失（如果 config.num_labels==1，则为回归损失）。 logits (`torch.Tensor`，形状为 `(batch_size, config.num_labels)`)：分类（如果 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[[transformers.PerceiverConfig]] #### transformers.PerceiverConfig[[transformers.PerceiverConfig]] ```python transformers.PerceiverConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_latents: int = 256, d_latents: int = 1280, d_model: int = 768, num_blocks: int = 1, num_self_attends_per_block: int = 26, num_self_attention_heads: int = 8, num_cross_attention_heads: int = 8, qk_channels: int | None = None, v_channels: int | None = None, cross_attention_shape_for_attention: str = 'kv', self_attention_widening_factor: int = 1, cross_attention_widening_factor: int = 1, hidden_act: str = 'gelu', attention_probs_dropout_prob: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, use_query_residual: bool = True, vocab_size: int = 262, max_position_embeddings: int = 2048, image_size: int | list[int] | tuple[int, int] = 56, train_size: list[int] | tuple[int, ...] = (368, 496), num_frames: int = 16, audio_samples_per_frame: int = 1920, samples_per_patch: int = 16, output_shape: list[int] | tuple[int, ...] = (1, 16, 224, 224), output_num_channels: int = 512, _label_trainable_num_channels: int = 1024) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/configuration_perceiver.py#L24) **参数：** 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`, *可选*) : 在编码器的交叉注意力和自注意力层中，应用注意力机制之前，将查询（queries）和键（keys）投影到的维度。如果未指定，则默认保留查询的维度。 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`，*可选*，默认为 `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](/docs/transformers/main/zh/model_doc/perceiver#transformers.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](https://huggingface.co/deepmind/language-perceiver) 类似的配置。 配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。 示例： ```python >>> from transformers import PerceiverModel, PerceiverConfig >>> # Initializing a Perceiver deepmind/language-perceiver style configuration >>> configuration = PerceiverConfig() >>> # Initializing a model from the deepmind/language-perceiver style configuration >>> model = PerceiverModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## PerceiverTokenizer[[transformers.PerceiverTokenizer]] #### transformers.PerceiverTokenizer[[transformers.PerceiverTokenizer]] ```python transformers.PerceiverTokenizer(pad_token = '[PAD]', bos_token = '[BOS]', eos_token = '[EOS]', mask_token = '[MASK]', cls_token = '[CLS]', sep_token = '[SEP]', model_max_length = 2048, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/tokenization_perceiver.py#L23) **参数：** 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](/docs/transformers/main/zh/main_classes/tokenizer#transformers.PythonBackend)，后者包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。 #### __调用__[[transformers.PerceiverTokenizer.__call__]] ```python __call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449) **参数：** 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](/docs/transformers/main/zh/internal/file_utils#transformers.utils.PaddingStrategy)，*可选*，默认为 `False`)：启用并控制填充。接受以下值： - `True` 或 `'longest'`：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。 - `'max_length'`：填充至由参数 `max_length` 指定的最大长度，或者如果未提供该参数，则填充至模型可接受的最大输入长度。 - `False` 或 `'do_not_pad'`（默认值）：不进行填充（即，可以输出包含不同长度序列的批次）。 truncation (`bool`、`str` 或 [TruncationStrategy](/docs/transformers/main/zh/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)，*optional*，默认为 `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），则禁用截断/填充至最大长度的功能。 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](/docs/transformers/main/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回张量而不是 Python 整数列表。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 Numpy `np.ndarray` 对象。 return_token_type_ids (`bool`，*可选*)：是否返回 token type ID。如果保持默认值，则根据特定 tokenizer 的默认设置返回 token type ID，该设置由 `return_outputs` 属性定义。[什么是 token type ID？](../glossary#token-type-ids) return_attention_mask (`bool`，*可选*)：是否返回注意力掩码。如果保持默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由 `return_outputs` 属性定义。[什么是注意力掩码？](../glossary#attention-mask) return_overflowing_tokens (`bool`，*可选*，默认为 `False`)：是否返回溢出的 token 序列。如果提供了输入 id 的序列对（或序列对的批次），并且 `truncation_strategy = longest_first` 或 `True`，则会引发错误，而不是返回溢出的 token。 return_special_tokens_mask (`bool`，*可选*，默认为 `False`)：是否返回特殊标记掩码信息。 return_offsets_mapping (`bool`，*可选*，默认为 `False`)：是否返回每个 token 的 `(char_start, char_end)`。此功能仅适用于继承自 [PreTrainedTokenizerFast](/docs/transformers/main/zh/main_classes/tokenizer#transformers.TokenizersBackend) 的快速分词器；如果使用 Python 分词器，此方法将抛出 `NotImplementedError`。 return_length (`bool`，*可选*，默认为 `False`)：是否返回编码后输入的长度。 verbose (`bool`，*可选*，默认为 `True`)：是否打印更多信息和警告。 - ****kwargs** : 传递给 `self.tokenize()` 方法 **返回：** [BatchEncoding](/docs/transformers/main/zh/main_classes/tokenizer#transformers.BatchEncoding) 一个包含以下字段的 [BatchEncoding](/docs/transformers/main/zh/main_classes/tokenizer#transformers.BatchEncoding)： - **input_ids** -- 输入模型的 token id 列表。 [什么是输入 ID？](../glossary#input-ids) - **token_type_ids** -- 要输入模型的 token 类型 ID 列表（当 `return_token_type_ids=True` 或 `self.model_input_names` 中包含 *"token_type_ids"* 时）。 [什么是 token type ID？](../glossary#token-type-ids) - **attention_mask** -- 指定模型应关注哪些 token 的索引列表（当 `return_attention_mask=True` 或 *"attention_mask"* 位于 `self.model_input_names` 中时）。 [什么是注意力掩码？](../glossary#attention-mask) - **overflowing_tokens** -- 溢出 token 序列的列表（当指定了 `max_length` 且 `return_overflowing_tokens=True` 时）。 - **num_truncated_tokens** -- 被截断的 token 数量（当指定了 `max_length` 且 `return_overflowing_tokens=True` 时）。 - **special_tokens_mask** -- 由 0 和 1 组成的列表，其中 1 表示添加的特殊标记，0 表示常规序列标记（当 `add_special_tokens=True` 且 `return_special_tokens_mask=True` 时）。 - **length** -- 输入的长度（当 `return_length=True` 时） 用于对一条或多条序列，或一对或多对序列进行分词并准备输入模型的主要方法。 ## PerceiverImageProcessor[[transformers.PerceiverImageProcessor]] #### transformers.PerceiverImageProcessor[[transformers.PerceiverImageProcessor]] ```python transformers.PerceiverImageProcessor(**kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/image_processing_perceiver.py#L33) **参数：** 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 为整数时，是否在调整大小时默认使用正方形图像。 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 图像处理器。 #### preprocess[[transformers.PerceiverImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382) **参数：** 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 为 int 时，是否在调整大小时默认使用正方形图像。 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[[transformers.PerceiverImageProcessorPil]] #### transformers.PerceiverImageProcessorPil[[transformers.PerceiverImageProcessorPil]] ```python transformers.PerceiverImageProcessorPil(**kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/image_processing_pil_perceiver.py#L31) **参数：** 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 为整数时，是否在调整大小时默认使用正方形图像。 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 图像处理器。 #### preprocess[[transformers.PerceiverImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382) **参数：** 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 为 int 时，是否在调整大小时默认使用正方形图像。 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]] #### transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2662) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置。 用于 Perceiver Encoder 的文本预处理。可用于嵌入 `inputs` 并添加位置编码。 嵌入的维度由配置中的 `d_model` 属性决定。 ## PerceiverImagePreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor(config, prep_type = 'conv', spatial_downsample: int = 4, temporal_downsample: int = 1, position_encoding_type: str = 'fourier', in_channels: int = 3, out_channels: int = 64, conv_after_patching: bool = False, conv_after_patching_in_channels: int = 54, conv2d_use_batchnorm: bool = True, concat_or_add_pos: str = 'concat', project_pos_dim: int = -1, **position_encoding_kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2825) **参数：** config （*PerceiverConfig*）：模型配置。 prep_type (`str`，*可选*，默认为 `"conv"`)：预处理类型。可以是 "conv1x1"、"conv"、"patches"、"pixels"。 spatial_downsample (`int`，*可选*，默认为 4)：空间下采样因子。 temporal_downsample (`int`，*可选*，默认为 1)：时间下采样因子（仅在存在时间维度时相关）。 position_encoding_type (`str`，*可选*，默认为 `"fourier"`)：位置编码类型。可以是 "fourier" 或 "trainable"。 in_channels (`int`，*可选*，默认为 3)：输入中的通道数。 out_channels (`int`，*可选*，默认为 64)：输出中的通道数。 conv_after_patching (`bool`, *可选*, 默认为 `False`) : 是否在分块后应用卷积层。 conv_after_patching_in_channels (`int`, *可选*，默认为 54)：分块后卷积层输入中的通道数。 conv2d_use_batchnorm (`bool`，*可选*，默认为 `True`)：是否在卷积层中使用批归一化。 concat_or_add_pos (`str`，*可选*，默认为 `"concat"`)：如何将位置编码与输入进行拼接。可以是 "concat" 或 "add"。 project_pos_dim (`int`，*可选*，默认为 -1)：位置编码要投影到的维度。如果为 -1，则不应用投影。 - ****position_encoding_kwargs** (`Dict`, *可选*) : 位置编码的关键字参数。 Perceiver Encoder 的图像预处理。 注意：*out_channels* 参数指的是卷积层的输出通道数，当 *prep_type* 设置为 "conv1x1" 或 "conv" 时。如果添加了绝对位置嵌入，则必须确保位置编码 kwargs 中的 *num_channels* 与 *out_channels* 相等。 ## PerceiverOneHotPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3063) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置。 Perceiver Encoder 的 One-hot 预处理器。可用于为输入添加一个虚拟的索引维度。 ## PerceiverAudioPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor(config, prep_type: str = 'patches', samples_per_patch: int = 96, position_encoding_type: str = 'fourier', concat_or_add_pos: str = 'concat', out_channels = 64, project_pos_dim = -1, **position_encoding_kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3089) **参数：** 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[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor(modalities: Mapping, mask_probs: collections.abc.Mapping[str, float] | None = None, min_padding_size: int = 2) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3192) **参数：** modalities (`Mapping[str, PreprocessorType]`) : 将模态名称映射到预处理器的字典。 mask_probs (`dict[str, float]`) : 将模态名称映射到该模态的掩码概率的字典。 min_padding_size (`int`, *可选*，默认为 2) : 所有模态的最小填充大小。最终输出的 num_channels 将等于所有模态中的最大通道数加上 min_padding_size。 Perceiver Encoder 的多模态预处理。 每种模态的输入经过预处理后，会使用可训练的位置嵌入进行填充，使其具有相同的通道数。 ## PerceiverProjectionDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder(config) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1839) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置。 基线投影解码器（无交叉注意力）。 ## PerceiverBasicDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder(config: PerceiverConfig, output_num_channels: int, position_encoding_type: str | None = 'trainable', output_index_dims: int | None = None, num_channels: int | None = 128, subsampled_index_dims: int | None = None, qk_channels: int | None = None, v_channels: int | None = None, num_heads: int | None = 1, widening_factor: int | None = 1, use_query_residual: bool | None = False, concat_preprocessed_input: bool | None = False, final_project: bool | None = True, position_encoding_only: bool | None = False, **position_encoding_kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1863) **参数：** 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`)：是否在查询和交叉注意力层的输出之间使用残差连接。 concat_preprocessed_input (`bool`，*可选*，默认为 `False`)：是否将预处理后的输入拼接到查询中。 final_project (`bool`, *可选*, 默认为 `True`) : 是否将交叉注意力层的输出投影到目标维度。 position_encoding_only (`bool`，*可选*，默认为 `False`)：是否仅使用此类来定义输出查询。 基于交叉注意力的解码器。此类可用于通过交叉注意力操作解码潜在变量的最终隐藏状态，其中潜在变量生成键和值。 该类的输出形状取决于如何定义输出查询（也称为解码器查询）。 ## PerceiverClassificationDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder(config, **decoder_kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2048) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置。 基于交叉注意力的分类解码器。`PerceiverBasicDecoder` 的轻量级封装，用于输出 logit。将 Perceiver 编码器输出的形状为 (batch_size, num_latents, d_latents) 的张量转换为形状为 (batch_size, num_labels) 的张量。查询的形状为 (batch_size, 1, num_labels)。 ## PerceiverOpticalFlowDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder(config, output_image_shape, output_num_channels = 2, rescale_factor = 100.0, **decoder_kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2094) 基于交叉注意力的光流解码器。 ## PerceiverBasicVideoAutoencodingDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder(config: PerceiverConfig, output_shape: list, position_encoding_type: str, **decoder_kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2129) **参数：** config （*PerceiverConfig*）：模型配置。 output_shape (`list[int]`) : 输出的形状为 (batch_size, num_frames, height, width)，不包括通道维度。 position_encoding_type (`str`) : 要使用的位置编码类型。可以是 "trainable"、"fourier" 或 "none"。 基于交叉注意力的视频自编码解码器。*PerceiverBasicDecoder* 的轻量级封装，包含视频重塑逻辑。 ## PerceiverMultimodalDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder(config: PerceiverConfig, modalities: dict, num_outputs: int, output_num_channels: int, min_padding_size: int | None = 2, subsampled_index_dims: dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder] | None = None, **decoder_kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2206) **参数：** 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[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor(in_channels: int, out_channels: int) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2804) **参数：** in_channels (`int`) : 输入中的通道数。 out_channels (`int`) : 输出中的通道数。 Perceiver 的投影后处理。可用于将解码器输出的通道投影到更低的维度。 ## PerceiverAudioPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor(config: PerceiverConfig, in_channels: int, postproc_type: str = 'patches') ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2777) **参数：** config （*PerceiverConfig*）：模型配置。 in_channels (`int`) : 输入中的通道数。 postproc_type (`str`，*可选*，默认为 `"patches"`)：要使用的后处理器类型。目前仅支持 "patches"。 Perceiver 的音频后处理。可用于将解码器输出转换为音频特征。 ## PerceiverClassificationPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor(config: PerceiverConfig, in_channels: int) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2757) **参数：** config （*PerceiverConfig*）：模型配置。 in_channels (`int`) : 输入中的通道数。 Perceiver 的分类后处理。可用于将解码器输出转换为分类 logits。 ## PerceiverMultimodalPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor(modalities: Mapping, input_is_dict: bool = False) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2723) **参数：** modalities (`Mapping[str, PostprocessorType]`) : 将模态名称映射到该模态的后处理器类的字典。 input_is_dict (`bool`，*可选*，默认为 `False`)：如果为 True，则假定输入为字典结构，输出将保持相同的字典形状。如果为 False，则输入为张量，在 *modality_sizes* 的后处理过程中会被切片。 Perceiver 的多模态后处理。可用于将特定模态的后处理器组合为单个后处理器。 ## PerceiverModel[[transformers.PerceiverModel]] #### transformers.PerceiverModel[[transformers.PerceiverModel]] ```python transformers.PerceiverModel(config: PerceiverConfig, decoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = None, input_preprocessor: Callable = None, output_postprocessor: Callable = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L561) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 decoder (`PerceiverDecoder`，*可选*)：将潜在表示转换为任务预测的解码器模块。 input_preprocessor (`PreprocessorType`，*可选*)：将原始输入编码为模型张量的预处理器。 output_postprocessor (`PostprocessorType`，*可选*)：将模型输出转换为最终预测的后处理器。 Perceiver：一种可扩展的、完全基于注意力的架构。 请注意，通过在模型的前向传播中将 `interpolate_pos_encoding` 设置为 `True`，可以对 Perceiver 进行微调，使其处理比训练时更高分辨率的图像。这会将预训练的位置嵌入插值到更高分辨率。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.PerceiverModel.forward]] ```python forward(inputs: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, subsampled_output_points: dict[str, torch.Tensor] | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L597) **参数：** inputs (`torch.Tensor`) : 输入到 perceiver 的数据。可以是任何类型：图像、文本、音频、视频等。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) 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](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 **返回：** [PerceiverModelOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput) 或 `tuple(torch.Tensor)` 一个 [PerceiverModelOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig)）和输入。 [PerceiverModel](/docs/transformers/main/zh/model_doc/perceiver#transformers.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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 示例： ```python >>> 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[[transformers.PerceiverForMaskedLM]] #### transformers.PerceiverForMaskedLM[[transformers.PerceiverForMaskedLM]] ```python transformers.PerceiverForMaskedLM(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L807) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Perceiver 用于掩码语言建模的示例用法。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.PerceiverForMaskedLM.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, input_ids: typing.Optional[torch.Tensor] = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L839) **参数：** inputs (`torch.Tensor`, *可选*) : 输入到 perceiver 的数据。可以是任何类型：图像、文本、音频、视频等。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) 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](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中各个 token 在词汇表中的索引。默认情况下，填充（padding）会被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) **返回：** [PerceiverMaskedLMOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput) 或 `tuple(torch.Tensor)` 一个 [PerceiverMaskedLMOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig)）和输入。 [PerceiverForMaskedLM](/docs/transformers/main/zh/model_doc/perceiver#transformers.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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 示例： ```python >>> from transformers import AutoTokenizer, PerceiverForMaskedLM >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver") >>> model = PerceiverForMaskedLM.from_pretrained("deepmind/language-perceiver") >>> # training >>> text = "This is an incomplete sentence where some words are missing." >>> inputs = tokenizer(text, padding="max_length", return_tensors="pt") >>> # mask " missing." >>> inputs["input_ids"][0, 52:61] = tokenizer.mask_token_id >>> labels = tokenizer(text, padding="max_length", return_tensors="pt").input_ids >>> outputs = model(**inputs, labels=labels) >>> loss = outputs.loss >>> round(loss.item(), 2) 19.87 >>> logits = outputs.logits >>> list(logits.shape) [1, 2048, 262] >>> # inference >>> text = "This is an incomplete sentence where some words are missing." >>> encoding = tokenizer(text, padding="max_length", return_tensors="pt") >>> # mask bytes corresponding to " missing.". Note that the model performs much better if the masked span starts with a space. >>> encoding["input_ids"][0, 52:61] = tokenizer.mask_token_id >>> # forward pass >>> with torch.no_grad(): ... outputs = model(**encoding) >>> logits = outputs.logits >>> list(logits.shape) [1, 2048, 262] >>> masked_tokens_predictions = logits[0, 52:61].argmax(dim=-1).tolist() >>> tokenizer.decode(masked_tokens_predictions) ' missing.' ``` ## PerceiverForSequenceClassification[[transformers.PerceiverForSequenceClassification]] #### transformers.PerceiverForSequenceClassification[[transformers.PerceiverForSequenceClassification]] ```python transformers.PerceiverForSequenceClassification(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L940) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Perceiver 用于文本分类的示例用法。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.PerceiverForSequenceClassification.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, input_ids: typing.Optional[torch.Tensor] = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L961) **参数：** inputs (`torch.Tensor`, *可选*) : 输入到 perceiver 的数据。可以是任何类型：图像、文本、音频、视频等。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) 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](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 input_ids (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中各个 token 在词汇表中的索引。默认情况下，填充（padding）会被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取这些索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) **返回：** [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `tuple(torch.Tensor)` 一个 [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig)）和输入。 [PerceiverForSequenceClassification](/docs/transformers/main/zh/model_doc/perceiver#transformers.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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 示例： ```python >>> from transformers import AutoTokenizer, PerceiverForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver") >>> model = PerceiverForSequenceClassification.from_pretrained("deepmind/language-perceiver") >>> text = "hello world" >>> inputs = tokenizer(text, return_tensors="pt").input_ids >>> outputs = model(inputs=inputs) >>> logits = outputs.logits >>> list(logits.shape) [1, 2] ``` ## PerceiverForImageClassificationLearned[[transformers.PerceiverForImageClassificationLearned]] #### transformers.PerceiverForImageClassificationLearned[[transformers.PerceiverForImageClassificationLearned]] ```python transformers.PerceiverForImageClassificationLearned(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1062) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Perceiver 在图像分类任务（例如 ImageNet）中的使用示例。 该模型使用学习得到的位置嵌入。换句话说，该模型未获得任何关于图像结构的特权信息。如论文所示，该模型在 ImageNet 上可达到 72.7 的 top-1 准确率。 [PerceiverForImageClassificationLearned](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) 使用 [PerceiverImagePreprocessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor)（其中 `prep_type="conv1x1"`）对输入图像进行预处理，并使用 [PerceiverClassificationDecoder](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) 将 [PerceiverModel](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverModel) 的潜在表示解码为分类 logits。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.PerceiverForImageClassificationLearned.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1093) **参数：** inputs (`torch.Tensor`, *可选*) : 输入到 perceiver 的数据。可以是任何类型：图像、文本、音频、视频等。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) 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](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [PerceiverImageProcessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverImageProcessor) 获取像素值。有关详细信息，请参阅 [PerceiverImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（`processor_class` 使用 [PerceiverImageProcessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverImageProcessor) 处理图像）。 **返回：** [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `tuple(torch.Tensor)` 一个 [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig)）和输入。 [PerceiverForImageClassificationLearned](/docs/transformers/main/zh/model_doc/perceiver#transformers.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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 示例： ```python >>> 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 cat ``` ## PerceiverForImageClassificationFourier[[transformers.PerceiverForImageClassificationFourier]] #### transformers.PerceiverForImageClassificationFourier[[transformers.PerceiverForImageClassificationFourier]] ```python transformers.PerceiverForImageClassificationFourier(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1187) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Perceiver 在图像分类任务（例如 ImageNet）中的使用示例。 该模型使用固定的 2D 傅里叶位置嵌入。如论文所示，该模型在 ImageNet 上可达到 79.0 的 top-1 准确率，在大规模数据集（即 JFT）上预训练后可达到 84.5。 [PerceiverForImageClassificationLearned](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) 使用 [PerceiverImagePreprocessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor)（设置 `prep_type="pixels"`）对输入图像进行预处理，并使用 [PerceiverClassificationDecoder](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) 将 [PerceiverModel](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverModel) 的潜在表示解码为分类 logits。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.PerceiverForImageClassificationFourier.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1219) **参数：** inputs (`torch.Tensor`, *可选*) : 输入到 perceiver 的数据。可以是任何类型：图像、文本、音频、视频等。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) 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](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [PerceiverImageProcessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverImageProcessor) 获取像素值。有关详细信息，请参阅 [PerceiverImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（`processor_class` 使用 [PerceiverImageProcessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverImageProcessor) 处理图像）。 **返回：** [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `tuple(torch.Tensor)` 一个 [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig)）和输入。 [PerceiverForImageClassificationFourier](/docs/transformers/main/zh/model_doc/perceiver#transformers.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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 示例： ```python >>> 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 cat ``` ## PerceiverForImageClassificationConvProcessing[[transformers.PerceiverForImageClassificationConvProcessing]] #### transformers.PerceiverForImageClassificationConvProcessing[[transformers.PerceiverForImageClassificationConvProcessing]] ```python transformers.PerceiverForImageClassificationConvProcessing(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1310) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Perceiver 在图像分类任务（例如 ImageNet）中的使用示例。 该模型使用 2D conv+maxpool 预处理网络。如论文所示，该模型在 ImageNet 上可达到 82.1 的 top-1 准确率。 [PerceiverForImageClassificationLearned](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) 使用 [PerceiverImagePreprocessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor)（其中 `prep_type="conv"`）对输入图像进行预处理，并使用 [PerceiverClassificationDecoder](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) 将 [PerceiverModel](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverModel) 的潜在表示解码为分类 logits。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.PerceiverForImageClassificationConvProcessing.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1343) **参数：** inputs (`torch.Tensor`, *可选*) : 输入到 perceiver 的数据。可以是任何类型：图像、文本、音频、视频等。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) 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](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [PerceiverImageProcessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverImageProcessor) 获取像素值。有关详细信息，请参阅 [PerceiverImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（`processor_class` 使用 [PerceiverImageProcessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverImageProcessor) 处理图像）。 **返回：** [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `tuple(torch.Tensor)` 一个 [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig)）和输入。 [PerceiverForImageClassificationConvProcessing](/docs/transformers/main/zh/model_doc/perceiver#transformers.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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 示例： ```python >>> 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 cat ``` ## PerceiverForOpticalFlow[[transformers.PerceiverForOpticalFlow]] #### transformers.PerceiverForOpticalFlow[[transformers.PerceiverForOpticalFlow]] ```python transformers.PerceiverForOpticalFlow(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1434) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Perceiver 在光流任务（如 Sintel 和 KITTI）中的示例用法。[PerceiverForOpticalFlow](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverForOpticalFlow) 使用 [PerceiverImagePreprocessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor)（设置 *prep_type="patches"*）对输入图像进行预处理，并使用 [PerceiverOpticalFlowDecoder](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder) 解码 [PerceiverModel](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverModel) 的潜在表示。 作为输入，将 2 个连续帧沿通道维度拼接，并提取每个像素周围的 3 x 3 补丁（导致每个像素有 3 x 3 x 3 x 2 = 54 个值）。使用固定的傅里叶位置编码来编码补丁中每个像素的位置。接下来，应用 Perceiver 编码器。为了解码，使用与输入相同的编码来查询潜在表示。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.PerceiverForOpticalFlow.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1484) **参数：** inputs (`torch.Tensor`, *可选*) : 输入到 perceiver 的数据。可以是任何类型：图像、文本、音频、视频等。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。 output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。 labels (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：用于计算光流损失的标签。索引应在 `[0, ..., config.num_labels - 1]` 范围内。 return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 **返回：** [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `tuple(torch.Tensor)` 一个 [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig)）和输入。 [PerceiverForOpticalFlow](/docs/transformers/main/zh/model_doc/perceiver#transformers.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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 示例： ```python >>> from transformers import PerceiverForOpticalFlow >>> import torch >>> model = PerceiverForOpticalFlow.from_pretrained("deepmind/optical-flow-perceiver") >>> # in the Perceiver IO paper, the authors extract a 3 x 3 patch around each pixel, >>> # leading to 3 x 3 x 3 = 27 values for each pixel (as each pixel also has 3 color channels) >>> # patches have shape (batch_size, num_frames, num_channels, height, width) >>> # the authors train on resolutions of 368 x 496 >>> patches = torch.randn(1, 2, 27, 368, 496) >>> outputs = model(inputs=patches) >>> logits = outputs.logits >>> list(logits.shape) [1, 368, 496, 2] ``` ## PerceiverForMultimodalAutoencoding[[transformers.PerceiverForMultimodalAutoencoding]] #### transformers.PerceiverForMultimodalAutoencoding[[transformers.PerceiverForMultimodalAutoencoding]] ```python transformers.PerceiverForMultimodalAutoencoding(config: PerceiverConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1576) **参数：** config ([PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 Perceiver 用于多模态（视频）自编码的示例用法，适用于 Kinetics-700 等任务。 [PerceiverForMultimodalAutoencoding](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverForMultimodalAutoencoding) 使用 [PerceiverMultimodalPreprocessor](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor) 对图像、音频和类别标签这三种模态进行预处理。该预处理器利用针对各模态的专用预处理器分别处理每种模态，随后将它们拼接在一起。通过可训练的位置嵌入，将每种模态填充至相同的通道数，从而实现在时间维度上的拼接。接下来，应用 Perceiver 编码器。 [PerceiverMultimodalDecoder](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder) 用于解码 [PerceiverModel](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverModel) 的潜在表示。该解码器使用每种模态特定的解码器来构建查询。解码器查询基于预处理后的输入创建。然而，在单次前向传播中对整个视频进行自编码在计算上是不可行的，因此仅使用部分解码器查询与潜在表示进行交叉注意力。这由每种模态的降采样索引决定，这些索引可以作为 [PerceiverForMultimodalAutoencoding](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverForMultimodalAutoencoding) 前向传播的额外输入提供。 [PerceiverMultimodalDecoder](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder) 还会将不同模态的解码器查询填充到相同的通道数，以便沿时间维度进行拼接。随后，使用 [PerceiverModel](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverModel) 的潜在表示执行交叉注意力。 最后，`~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor` 用于将该张量转换为实际的视频。它首先将输出拆分为不同的模态，然后对每个模态应用相应的后处理器。 请注意，在评估期间对分类标签进行掩码处理（即仅为“label”模态提供一个全零张量），该自编码模型即可用作 Kinetics 700 视频分类器。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.PerceiverForMultimodalAutoencoding.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, subsampled_output_points: dict[str, torch.Tensor] | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1692) **参数：** inputs (`torch.Tensor`, *可选*) : 输入到 perceiver 的数据。可以是任何类型：图像、文本、音频、视频等。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) subsampled_output_points (`dict[str, torch.Tensor]`, *可选*) : 用作解码器查询的张量字典。解码器会将这些查询映射到模型的潜在表示。用于子采样解码，例如仅解码某些图像块时。 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](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。 **返回：** [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `tuple(torch.Tensor)` 一个 [PerceiverClassifierOutput](/docs/transformers/main/zh/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[PerceiverConfig](/docs/transformers/main/zh/model_doc/perceiver#transformers.PerceiverConfig)）和输入。 [PerceiverForMultimodalAutoencoding](/docs/transformers/main/zh/model_doc/perceiver#transformers.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 之后的注意力权重，用于在交叉注意力头中计算加权平均值。 示例： ```python >>> 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] ```