Transformers 4.37 中文文档（九十二）（4）

Transformers 4.37 中文文档（九十二）（3）https://developer.aliyun.com/article/1563884

PerceiverProjectionPostprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor

<来源>

( in_channels: int out_channels: int )

参数

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

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

PerceiverAudioPostprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor

<来源>

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

参数

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

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

PerceiverClassificationPostprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor

<来源>

( config: PerceiverConfig in_channels: int )

参数

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

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

PerceiverMultimodalPostprocessor

class transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor

<来源>

( modalities: Mapping input_is_dict: bool = False )

参数

• modalities (Mapping[str, PostprocessorType]) — 将模态名称映射到该模态的后处理器类的字典。
  
• input_is_dict（bool，可选，默认为False）— 如果为 True，则假定输入为字典结构，并且输出保持相同的字典形状。如果为 False，则输入是一个张量，在后处理过程中由modality_sizes切片。
  

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

PerceiverModel

class transformers.PerceiverModel

<来源>

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

参数

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

感知器：一种可扩展的完全注意力架构。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( inputs: FloatTensor attention_mask: Optional = None subsampled_output_points: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput or tuple(torch.FloatTensor)

参数

• inputs（torch.FloatTensor）— 输入到感知器。可以是任何内容：图像、文本、音频、视频等。
  
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的遮罩。选择在[0, 1]范围内的遮罩值：

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

• 什么是注意力遮罩？
  
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的遮罩。选择在[0, 1]范围内的遮罩值：

• 1 表示头部未被遮罩，
  
• 0 表示头部被遮罩。
  

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
  

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput 或tuple(torch.FloatTensor)

transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（PerceiverConfig）和输入。

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

PerceiverModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者负责运行前处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import PerceiverConfig, PerceiverTokenizer, PerceiverImageProcessor, PerceiverModel
>>> from transformers.models.perceiver.modeling_perceiver import (
...     PerceiverTextPreprocessor,
...     PerceiverImagePreprocessor,
...     PerceiverClassificationDecoder,
... )
>>> import torch
>>> import requests
>>> from PIL import Image
>>> # EXAMPLE 1: using the Perceiver to classify texts
>>> # - we define a TextPreprocessor, which can be used to embed tokens
>>> # - we define a ClassificationDecoder, which can be used to decode the
>>> # final hidden states of the latents to classification logits
>>> # using trainable position embeddings
>>> config = PerceiverConfig()
>>> preprocessor = PerceiverTextPreprocessor(config)
>>> decoder = PerceiverClassificationDecoder(
...     config,
...     num_channels=config.d_latents,
...     trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
...     use_query_residual=True,
... )
>>> model = PerceiverModel(config, input_preprocessor=preprocessor, decoder=decoder)
>>> # you can then do a forward pass as follows:
>>> tokenizer = PerceiverTokenizer()
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> with torch.no_grad():
...     outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()
>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)
>>> # EXAMPLE 2: using the Perceiver to classify images
>>> # - we define an ImagePreprocessor, which can be used to embed images
>>> config = PerceiverConfig(image_size=224)
>>> preprocessor = PerceiverImagePreprocessor(
...     config,
...     prep_type="conv1x1",
...     spatial_downsample=1,
...     out_channels=256,
...     position_encoding_type="trainable",
...     concat_or_add_pos="concat",
...     project_pos_dim=256,
...     trainable_position_encoding_kwargs=dict(
...         num_channels=256,
...         index_dims=config.image_size**2,
...     ),
... )
>>> model = PerceiverModel(
...     config,
...     input_preprocessor=preprocessor,
...     decoder=PerceiverClassificationDecoder(
...         config,
...         num_channels=config.d_latents,
...         trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
...         use_query_residual=True,
...     ),
... )
>>> # you can then do a forward pass as follows:
>>> image_processor = PerceiverImageProcessor()
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(image, return_tensors="pt").pixel_values
>>> with torch.no_grad():
...     outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()
>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)

PerceiverForMaskedLM

class transformers.PerceiverForMaskedLM

<源代码>

( config: PerceiverConfig )

参数

• config（PerceiverConfig）- 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

Perceiver 用于填充语言建模的示例用法。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

<源代码>

( inputs: Optional = None attention_mask: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None input_ids: Optional = None ) → export const metadata = 'undefined';transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput or tuple(torch.FloatTensor)

参数

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

• 1 表示not masked的标记，
  
• 0 表示masked的标记。
  

• 什么是注意力掩码？
  
• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：

• 1 表示头部是not masked，
  
• 0 表示头部被masked。
  

• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
  
• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
  
• return_dict (bool，optional) — 是否返回 ModelOutput 而不是普通元组。
  
• labels (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（masked），损失仅计算具有标签在[0, ..., config.vocab_size]内的标记
  

返回

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

一个 transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包括根据配置(PerceiverConfig)和输入的各种元素。

• loss (torch.FloatTensor，形状为(1,)，optional, 当提供labels时返回) — 掩码语言建模（MLM）损失。
  
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。每层输出的隐藏状态加上初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, num_latents, num_latents)的torch.FloatTensor元组。自注意力头部中的注意力权重 softmax 后，用于计算加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的交叉注意力层的注意力权重，在注意力 softmax 后使用，用于计算交叉注意力头部中的加权平均值。
  

PerceiverForMaskedLM 的前向方法，覆盖__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, PerceiverForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForMaskedLM.from_pretrained("deepmind/language-perceiver")
>>> # training
>>> text = "This is an incomplete sentence where some words are missing."
>>> inputs = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask " missing."
>>> inputs["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> labels = tokenizer(text, padding="max_length", return_tensors="pt").input_ids
>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
19.87
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]
>>> # inference
>>> text = "This is an incomplete sentence where some words are missing."
>>> encoding = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask bytes corresponding to " missing.". Note that the model performs much better if the masked span starts with a space.
>>> encoding["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> # forward pass
>>> with torch.no_grad():
...     outputs = model(**encoding)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]
>>> masked_tokens_predictions = logits[0, 52:61].argmax(dim=-1).tolist()
>>> tokenizer.decode(masked_tokens_predictions)
' missing.'

PerceiverForSequenceClassification

class transformers.PerceiverForSequenceClassification

< source >

( config )

参数

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

Perceiver 用于文本分类的示例。这个模型是 PyTorch 的 torch.nn.Module 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

< source >

( inputs: Optional = None attention_mask: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None input_ids: Optional = None ) → export const metadata = 'undefined';transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput or tuple(torch.FloatTensor)

参数

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

• 1 表示标记未被masked，
  
• 对于被masked的标记为 0。
  

• 什么是注意力掩码？
  
• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1]：

• 1 表示头部未被masked，
  
• 0 表示头部被masked。
  

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  
• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  
• labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1]。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。
  

返回值

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或者 tuple(torch.FloatTensor)

transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput 或者一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或者 config.return_dict=False）包含各种元素，取决于配置（PerceiverConfig）和输入。

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

PerceiverForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, PerceiverForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForSequenceClassification.from_pretrained("deepmind/language-perceiver")
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]

Transformers 4.37 中文文档（九十二）（5）https://developer.aliyun.com/article/1563886