Transformers 4.37 中文文档（九十二）（2）-阿里云开发者社区

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

Owlv2TextModel

`class transformers.Owlv2TextModel`

( config: Owlv2TextConfig )

`forward`

<来源>

( input_ids: Tensor attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size * num_max_text_queries, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？
attention_mask（形状为(batch_size, num_max_text_queries, sequence_length)的torch.Tensor，可选）— 避免在填充标记索引上执行注意力的蒙版。在[0, 1]中选择的蒙版值：

对于“未屏蔽”的标记返回 1，
对于“屏蔽”的标记返回 0。什么是注意力蒙版？

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

transformers.modeling_outputs.BaseModelOutputWithPooling 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，这取决于配置（）和输入。

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。
pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后，序列中第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
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, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, Owlv2TextModel
>>> model = Owlv2TextModel.from_pretrained("google/owlv2-base-patch16")
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16")
>>> inputs = processor(
...     text=[["a photo of a cat", "a photo of a dog"], ["photo of a astranaut"]], return_tensors="pt"
... )
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

Owlv2VisionModel

`class transformers.Owlv2VisionModel`

<来源>

( config: Owlv2VisionConfig )

`forward`

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

transformers.modeling_outputs.BaseModelOutputWithPooling 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置()和输入的不同元素。

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 序列的第一个标记（分类标记）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理后。例如，对于 BERT 系列模型，这返回经过线性层和双曲正切激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
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, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Owlv2VisionModel
>>> model = Owlv2VisionModel.from_pretrained("google/owlv2-base-patch16")
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states

Owlv2ForObjectDetection

`class transformers.Owlv2ForObjectDetection`

<来源>

( config: Owlv2Config )

`forward`

<来源>

( input_ids: Tensor pixel_values: FloatTensor attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.owlv2.modeling_owlv2.Owlv2ObjectDetectionOutput or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。
input_ids (torch.LongTensor of shape (batch_size * num_max_text_queries, sequence_length), optional) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？。
attention_mask (torch.Tensor of shape (batch_size, num_max_text_queries, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间：

1 用于 not masked 的标记，
0 用于 masked 的标记。什么是注意力掩码？

output_hidden_states (bool, optional) — 是否返回最后一个隐藏状态。有关更多详细信息，请参阅返回张量中的 text_model_last_hidden_state 和 vision_model_last_hidden_state。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

transformers.models.owlv2.modeling_owlv2.Owlv2ObjectDetectionOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.owlv2.modeling_owlv2.Owlv2ObjectDetectionOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False 或 config.return_dict=False）包含根据配置（）和输入而异的各种元素。

loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回)） — 总损失，作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
loss_dict (Dict，可选） — 包含各个损失的字典。用于记录。
logits (torch.FloatTensor，形状为(batch_size, num_patches, num_queries)) — 所有查询的分类 logits（包括无对象）。
objectness_logits (torch.FloatTensor，形状为(batch_size, num_patches, 1)) — 所有图像补丁的目标性 logits。OWL-ViT 将图像表示为一组图像补丁，其中补丁的总数为（图像大小/补丁大小）**2。
pred_boxes (torch.FloatTensor，形状为(batch_size, num_patches, 4)) — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未归一化的边界框。
text_embeds (torch.FloatTensor，形状为(batch_size, num_max_text_queries, output_dim) — 通过将投影层应用于 Owlv2TextModel 的汇集输出获得的文本嵌入。
image_embeds (torch.FloatTensor，形状为(batch_size, patch_size, patch_size, output_dim) — Owlv2VisionModel 的汇集输出。OWLv2 将图像表示为一组图像补丁，并为每个补丁计算图像嵌入。
class_embeds (torch.FloatTensor，形状为(batch_size, num_patches, hidden_size)) — 所有图像补丁的类别嵌入。OWLv2 将图像表示为一组图像补丁，其中补丁的总数为（图像大小/补丁大小）**2。
text_model_output (TupleBaseModelOutputWithPooling) — Owlv2TextModel 的输出。
vision_model_output (BaseModelOutputWithPooling) — Owlv2VisionModel 的输出。

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

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

示例：

>>> import requests
>>> from PIL import Image
>>> import numpy as np
>>> import torch
>>> from transformers import AutoProcessor, Owlv2ForObjectDetection
>>> from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> model = Owlv2ForObjectDetection.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = [["a photo of a cat", "a photo of a dog"]]
>>> inputs = processor(text=texts, images=image, return_tensors="pt")
>>> # forward pass
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> # Note: boxes need to be visualized on the padded, unnormalized image
>>> # hence we'll set the target image sizes (height, width) based on that
>>> def get_preprocessed_image(pixel_values):
...     pixel_values = pixel_values.squeeze().numpy()
...     unnormalized_image = (pixel_values * np.array(OPENAI_CLIP_STD)[:, None, None]) + np.array(OPENAI_CLIP_MEAN)[:, None, None]
...     unnormalized_image = (unnormalized_image * 255).astype(np.uint8)
...     unnormalized_image = np.moveaxis(unnormalized_image, 0, -1)
...     unnormalized_image = Image.fromarray(unnormalized_image)
...     return unnormalized_image
>>> unnormalized_image = get_preprocessed_image(inputs.pixel_values)
>>> target_sizes = torch.Tensor([unnormalized_image.size[::-1]])
>>> # Convert outputs (bounding boxes and class logits) to final bounding boxes and scores
>>> results = processor.post_process_object_detection(
...     outputs=outputs, threshold=0.2, target_sizes=target_sizes
... )
>>> i = 0  # Retrieve predictions for the first image for the corresponding text queries
>>> text = texts[i]
>>> boxes, scores, labels = results[i]["boxes"], results[i]["scores"], results[i]["labels"]
>>> for box, score, label in zip(boxes, scores, labels):
...     box = [round(i, 2) for i in box.tolist()]
...     print(f"Detected {text[label]} with confidence {round(score.item(), 3)} at location {box}")
Detected a photo of a cat with confidence 0.614 at location [512.5, 35.08, 963.48, 557.02]
Detected a photo of a cat with confidence 0.665 at location [10.13, 77.94, 489.93, 709.69]

`image_guided_detection`

< source >

( pixel_values: FloatTensor query_pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.owlv2.modeling_owlv2.Owlv2ImageGuidedObjectDetectionOutput or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。
query_pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 要检测的查询图像的像素值。每个目标图像传入一个查询图像。
output_attentions (bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states (bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool，可选） — 是否返回 ModelOutput 而不是普通元组。

transformers.models.owlv2.modeling_owlv2.Owlv2ImageGuidedObjectDetectionOutput 或 tuple(torch.FloatTensor)

一个transformers.models.owlv2.modeling_owlv2.Owlv2ImageGuidedObjectDetectionOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（）和输入。

logits (torch.FloatTensor，形状为(batch_size, num_patches, num_queries)) — 所有查询的分类 logits（包括无对象）。
target_pred_boxes (torch.FloatTensor，形状为(batch_size, num_patches, 4)) — 所有查询的标准化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内标准化，相对于批处理中每个单独目标图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未标准化的边界框。
query_pred_boxes (torch.FloatTensor，形状为(batch_size, num_patches, 4)) — 所有查询的标准化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内标准化，相对于批处理中每个单独查询图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未标准化的边界框。
image_embeds (torch.FloatTensor，形状为(batch_size, patch_size, patch_size, output_dim) — Owlv2VisionModel 的汇总输出。OWLv2 将图像表示为一组图像补丁，并为每个补丁计算图像嵌入。
query_image_embeds (torch.FloatTensor，形状为(batch_size, patch_size, patch_size, output_dim) — Owlv2VisionModel 的汇总输出。OWLv2 将图像表示为一组图像补丁，并为每个补丁计算图像嵌入。
class_embeds (torch.FloatTensor，形状为(batch_size, num_patches, hidden_size)) — 所有图像补丁的类别嵌入。OWLv2 将图像表示为一组图像补丁，其中补丁的总数为（图像大小/补丁大小）**2。
text_model_output (TupleBaseModelOutputWithPooling) — Owlv2TextModel 的输出。
vision_model_output (BaseModelOutputWithPooling) — Owlv2VisionModel 的输出。

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

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

示例：

>>> import requests
>>> from PIL import Image
>>> import torch
>>> import numpy as np
>>> from transformers import AutoProcessor, Owlv2ForObjectDetection
>>> from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> model = Owlv2ForObjectDetection.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> query_url = "http://images.cocodataset.org/val2017/000000001675.jpg"
>>> query_image = Image.open(requests.get(query_url, stream=True).raw)
>>> inputs = processor(images=image, query_images=query_image, return_tensors="pt")
>>> # forward pass
>>> with torch.no_grad():
...     outputs = model.image_guided_detection(**inputs)
>>> # Note: boxes need to be visualized on the padded, unnormalized image
>>> # hence we'll set the target image sizes (height, width) based on that
>>> def get_preprocessed_image(pixel_values):
...     pixel_values = pixel_values.squeeze().numpy()
...     unnormalized_image = (pixel_values * np.array(OPENAI_CLIP_STD)[:, None, None]) + np.array(OPENAI_CLIP_MEAN)[:, None, None]
...     unnormalized_image = (unnormalized_image * 255).astype(np.uint8)
...     unnormalized_image = np.moveaxis(unnormalized_image, 0, -1)
...     unnormalized_image = Image.fromarray(unnormalized_image)
...     return unnormalized_image
>>> unnormalized_image = get_preprocessed_image(inputs.pixel_values)
>>> target_sizes = torch.Tensor([unnormalized_image.size[::-1]])
>>> # Convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> results = processor.post_process_image_guided_detection(
...     outputs=outputs, threshold=0.9, nms_threshold=0.3, target_sizes=target_sizes
... )
>>> i = 0  # Retrieve predictions for the first image
>>> boxes, scores = results[i]["boxes"], results[i]["scores"]
>>> for box, score in zip(boxes, scores):
...     box = [round(i, 2) for i in box.tolist()]
...     print(f"Detected similar object with confidence {round(score.item(), 3)} at location {box}")
Detected similar object with confidence 0.938 at location [490.96, 109.89, 821.09, 536.11]
Detected similar object with confidence 0.959 at location [8.67, 721.29, 928.68, 732.78]
Detected similar object with confidence 0.902 at location [4.27, 720.02, 941.45, 761.59]
Detected similar object with confidence 0.985 at location [265.46, -58.9, 1009.04, 365.66]
Detected similar object with confidence 1.0 at location [9.79, 28.69, 937.31, 941.64]
Detected similar object with confidence 0.998 at location [869.97, 58.28, 923.23, 978.1]
Detected similar object with confidence 0.985 at location [309.23, 21.07, 371.61, 932.02]
Detected similar object with confidence 0.947 at location [27.93, 859.45, 969.75, 915.44]
Detected similar object with confidence 0.996 at location [785.82, 41.38, 880.26, 966.37]
Detected similar object with confidence 0.998 at location [5.08, 721.17, 925.93, 998.41]
Detected similar object with confidence 0.969 at location [6.7, 898.1, 921.75, 949.51]
Detected similar object with confidence 0.966 at location [47.16, 927.29, 981.99, 942.14]
Detected similar object with confidence 0.924 at location [46.4, 936.13, 953.02, 950.78

Perceiver

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/perceiver

概述

Perceiver IO 模型由 Andrew Jaegle、Sebastian Borgeaud、Jean-Baptiste Alayrac、Carl Doersch、Catalin Ionescu、David Ding、Skanda Koppula、Daniel Zoran、Andrew Brock、Evan Shelhamer、Olivier Hénaff、Matthew M. Botvinick、Andrew Zisserman、Oriol Vinyals、João Carreira 在《Perceiver IO: A General Architecture for Structured Inputs & Outputs》中提出。

Perceiver IO 是对 Perceiver 的泛化，可以处理任意输出以及任意输入。原始的 Perceiver 只产生单个分类标签。除了分类标签，Perceiver IO 还可以生成（例如）语言、光流和带有音频的多模态视频。这是使用与原始 Perceiver 相同的构建模块完成的。Perceiver IO 的计算复杂度与输入和输出大小呈线性关系，大部分处理发生在潜在空间中，使我们能够处理比标准 Transformer 处理能力更大的输入和输出。这意味着，例如，Perceiver IO 可以直接使用字节执行类似 BERT 的掩码语言建模，而不是使用标记化的输入。

论文的摘要如下：

最近提出的 Perceiver 模型在多个领域（图像、音频、多模态、点云）上取得了良好的结果，同时在计算和内存方面与输入大小呈线性关系。虽然 Perceiver 支持多种类型的输入，但它只能产生非常简单的输出，如类别分数。Perceiver IO 通过学习灵活地查询模型的潜在空间来产生任意大小和语义的输出，克服了这一限制，同时保留了原始模型的吸引人特性。Perceiver IO 仍然将模型深度与数据大小分离，并且仍然与数据大小呈线性关系，但现在是相对于输入和输出大小。完整的 Perceiver IO 模型在具有高度结构化输出空间的任务上取得了强大的结果，例如自然语言和视觉理解、星际争霸 II 以及多任务和多模态领域。作为亮点，Perceiver IO 在 GLUE 语言基准测试中与基于 Transformer 的 BERT 基线相匹配，无需输入标记化，并在 Sintel 光流估计中实现了最先进的性能。

以下是 Perceiver 工作原理的 TLDR：

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

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

这是原始 Perceiver 论文的想法。但是，它只能输出分类 logits。在后续工作 PerceiverIO 中，他们将其泛化，使模型还可以产生任意大小的输出。你可能会问，如何实现？其实想法相对简单：定义任意大小的输出，然后使用潜在变量的最后隐藏状态执行交叉注意力，使用输出作为查询，潜在变量作为键和值。

那么假设有人想要使用 Perceiver 执行掩码语言建模（类似 BERT）。由于 Perceiver 的输入长度不会影响自注意力层的计算时间，可以提供原始字节，将inputs的长度提供给模型为 2048。如果现在屏蔽掉这 2048 个标记中的某些标记，可以将outputs定义为形状为：(batch_size, 2048, 768)。接下来，使用潜在变量的最终隐藏状态执行交叉注意力以更新outputs张量。经过交叉注意力后，仍然有形状为(batch_size, 2048, 768)的张量。然后可以在顶部放置一个常规的语言建模头部，将最后一个维度投影到模型的词汇量大小，即创建形状为(batch_size, 2048, 262)的 logits（因为 Perceiver 使用 262 个字节 ID 的词汇量大小）。

Perceiver IO 架构。取自原始论文

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

Perceiver 不与torch.nn.DataParallel一起使用，因为 PyTorch 中存在错误，请参阅问题＃36035

资源

开始使用 Perceiver 的最快方法是查看教程笔记本。
如果您想要完全了解模型如何工作并在库中实现，请参考博客文章。请注意，库中提供的模型仅展示了您可以使用 Perceiver 做什么的一些示例。还有许多其他用例，包括问答，命名实体识别，目标检测，音频分类，视频分类等。
文本分类任务指南
掩码语言建模任务指南
图像分类任务指南

Perceiver 特定的输出

`class transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput`

<来源>

( logits: FloatTensor = None last_hidden_state: FloatTensor = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )

参数

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 后用于计算交叉注意力头中的加权平均值。

Perceiver 基础模型输出的基类，包括潜在的隐藏状态、注意力和交叉注意力。

`class transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput`

<来源>

( logits: FloatTensor = None cross_attentions: Optional = None )

参数

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

Perceiver 解码器输出的基类，包括潜在的交叉注意力。

`class transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput`

<来源>

( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )

参数

loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 掩码语言建模（MLM）损失。
logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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, num_latents, num_latents)的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 后用于计算交叉注意力头中的加权平均值。

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

`class transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput`

<来源>

( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )

参数

loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(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 之后，用于计算交叉注意力头中的加权平均值。

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

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

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

Owlv2TextModel

`class transformers.Owlv2TextModel`

`forward`

Owlv2VisionModel

`class transformers.Owlv2VisionModel`

`forward`

Owlv2ForObjectDetection

`class transformers.Owlv2ForObjectDetection`

`forward`

`image_guided_detection`

Perceiver

概述

资源

Perceiver 特定的输出

`class transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput`

`class transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput`

`class transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput`

`class transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

Owlv2TextModel

class transformers.Owlv2TextModel

forward

Owlv2VisionModel

class transformers.Owlv2VisionModel

forward

Owlv2ForObjectDetection

class transformers.Owlv2ForObjectDetection

forward

image_guided_detection

Perceiver

概述

资源

Perceiver 特定的输出

class transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput

class transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput

class transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput

class transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput

热门文章

最新文章

相关课程

相关电子书

`class transformers.Owlv2TextModel`

`forward`

`class transformers.Owlv2VisionModel`

`forward`

`class transformers.Owlv2ForObjectDetection`

`forward`

`image_guided_detection`

`class transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput`

`class transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput`

`class transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput`

`class transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput`