Transformers 4.37 中文文档（六十六）

原文：huggingface.co/docs/transformers

Deformable DETR

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/deformable_detr

概述

Deformable DETR 模型是由 Xizhou Zhu，Weijie Su，Lewei Lu，Bin Li，Xiaogang Wang，Jifeng Dai 在Deformable DETR: Deformable Transformers for End-to-End Object Detection中提出的。Deformable DETR 通过利用一个新的可变形注意力模块，该模块只关注参考周围一小组关键采样点，从而缓解了原始 DETR 的收敛速度慢和特征空间分辨率有限的问题。

论文摘要如下：

DETR 最近被提出，旨在消除目标检测中许多手工设计的组件的需求，同时表现良好。然而，由于 Transformer 注意力模块在处理图像特征图时的限制，它存在收敛速度慢和特征空间分辨率有限的问题。为了缓解这些问题，我们提出了 Deformable DETR，其注意力模块只关注参考周围一小组关键采样点。Deformable DETR 可以比 DETR 实现更好的性能（特别是对于小目标），并且训练时长减少了 10 倍。在 COCO 基准测试上的大量实验证明了我们方法的有效性。

drawing

Deformable DETR 架构。摘自原始论文。

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

使用提示

• 训练 Deformable DETR 等同于训练原始 DETR 模型。有关演示笔记本，请参见下面的资源部分。

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 Deformable DETR。

目标检测

• 关于在自定义数据集上进行推理+微调的演示笔记本，可以在这里找到。
• 另请参阅：目标检测任务指南。

如果您有兴趣提交资源以包含在此处，请随时提出拉取请求，我们将对其进行审查！资源应该展示一些新内容，而不是重复现有资源。

DeformableDetrImageProcessor

class transformers.DeformableDetrImageProcessor

<来源>

( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )

参数

• format (str，可选，默认为"coco_detection") — 注释的数据格式。其中之一是"coco_detection"或“coco_panoptic”。
• do_resize (bool，可选，默认为True) — 控制是否将图像的（高度，宽度）尺寸调整为指定的size。可以通过preprocess方法中的do_resize参数进行覆盖。
• size (Dict[str, int] 可选，默认为{"shortest_edge" -- 800, "longest_edge": 1333})：调整大小后的图像（高度，宽度）尺寸。可以通过preprocess方法中的size参数进行覆盖。
• resample (PILImageResampling，可选，默认为PILImageResampling.BILINEAR) — 如果调整图像大小，则要使用的重采样滤波器。
• do_rescale (bool，可选，默认为True) — 控制是否按指定比例rescale_factor对图像进行重新缩放。可以通过preprocess方法中的do_rescale参数进行覆盖。
• rescale_factor（int或float，可选，默认为1/255）— 如果重新缩放图像，则使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。do_normalize — 控制是否规范化图像。可以被preprocess方法中的do_normalize参数覆盖。
• image_mean（float或List[float]，可选，默认为IMAGENET_DEFAULT_MEAN）— 在规范化图像时使用的均值。可以是单个值或值列表，每个通道一个值。可以被preprocess方法中的image_mean参数覆盖。
• image_std（float或List[float]，可选，默认为IMAGENET_DEFAULT_STD）— 在规范化图像时使用的标准差值。可以是单个值或值列表，每个通道一个值。可以被preprocess方法中的image_std参数覆盖。
• do_pad（bool，可选，默认为True）— 控制是否将图像填充到批次中最大的图像并创建像素掩模。可以被preprocess方法中的do_pad参数覆盖。

构造一个可变形 DETR 图像处理器。

preprocess

<来源>

( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images（ImageInput）— 要预处理的图像或图像批次。期望单个图像或像素值范围从 0 到 255 的图像批次。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。
• annotations（AnnotationType或List[AnnotationType]，可选）— 与图像或图像批次关联的注释列表。如果注释用于目标检测，则注释应该是一个带有以下键的字典：
  • “image_id”（int）：图像 ID。
  • “annotations”（List[Dict]）：图像的注释列表。每个注释应该是一个字典。一个图像可以没有注释，此时列表应为空。如果注释是用于分割的，注释应该是一个带有以下键的字典：
  • “image_id”（int）：图像 ID。
  • “segments_info”（List[Dict]）：图像的分段列表。每个分段应该是一个字典。一个图像可以没有分段，此时列表应为空。
  • “file_name”（str）：图像的文件名。
• return_segmentation_masks（bool，可选，默认为 self.return_segmentation_masks）— 是否返回分割掩模。
• masks_path（str或pathlib.Path，可选）— 包含分割掩模的目录的路径。
• do_resize（bool，可选，默认为 self.do_resize）— 是否调整图像大小。
• size（Dict[str, int]，可选，默认为 self.size）— 调整大小后的图像尺寸。
• resample（PILImageResampling，可选，默认为 self.resample）— 调整图像大小时要使用的重采样滤波器。
• do_rescale（bool，可选，默认为 self.do_rescale）— 是否重新缩放图像。
• rescale_factor（float，可选，默认为 self.rescale_factor）— 重新缩放图像时使用的比例因子。
• do_normalize（bool，可选，默认为 self.do_normalize）— 是否规范化图像。
• image_mean（float或List[float]，可选，默认为 self.image_mean）— 在规范化图像时使用的均值。
• image_std（float或List[float]，可选，默认为 self.image_std）— 在规范化图像时使用的标准差。
• do_pad（bool，可选，默认为 self.do_pad）— 是否填充图像。
• format（str或AnnotationFormat，可选，默认为 self.format）— 注释的格式。
• return_tensors（str或TensorType，可选，默认为 self.return_tensors）— 要返回的张量类型。如果为None，将返回图像列表。
• data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST：图像以 (通道数, 高度, 宽度) 格式。
  • "channels_last" 或 ChannelDimension.LAST：图像以 (高度, 宽度, 通道数) 格式。
  • 未设置：使用输入图像的通道维度格式。
• input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST：图像以 (通道数, 高度, 宽度) 格式。
  • "channels_last" 或 ChannelDimension.LAST：图像以 (高度, 宽度, 通道数) 格式。
  • "none" 或 ChannelDimension.NONE：图像以 (高度, 宽度) 格式。

预处理图像或图像批次，以便模型可以使用。

post_process_object_detection

<来源>

( outputs threshold: float = 0.5 target_sizes: Union = None top_k: int = 100 ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (DetrObjectDetectionOutput) — 模型的原始输出。
• threshold (float, 可选) — 保留目标检测预测的分数阈值。
• target_sizes (torch.Tensor 或 List[Tuple[int, int]], 可选) — 形状为 (batch_size, 2) 的张量或包含批次中每个图像目标大小 (高度, 宽度) 的元组列表 (Tuple[int, int])。如果为 None，则预测不会被调整大小。
• top_k (int, 可选, 默认为 100) — 在通过阈值过滤之前仅保留前 k 个边界框。

返回

List[Dict]

一个字典列表，每个字典包含模型预测的批次中每个图像的分数、标签和框。

将 DeformableDetrForObjectDetection 的原始输出转换为最终的边界框，格式为 (左上角 x 坐标, 左上角 y 坐标, 右下角 x 坐标, 右下角 y 坐标)。仅支持 PyTorch。

DeformableDetrFeatureExtractor

class transformers.DeformableDetrFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

预处理图像或图像批次。

post_process_object_detection

<来源>

( outputs threshold: float = 0.5 target_sizes: Union = None top_k: int = 100 ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (DetrObjectDetectionOutput) — 模型的原始输出。
• threshold (float, 可选) — 保留目标检测预测的分数阈值。
• target_sizes (torch.Tensor 或 List[Tuple[int, int]], 可选) — 形状为 (batch_size, 2) 的张量或包含批次中每个图像目标大小 (高度, 宽度) 的元组列表 (Tuple[int, int])。如果为 None，则预测不会被调整大小。
• top_k (int, 可选, 默认为 100) — 在通过阈值过滤之前仅保留前 k 个边界框。

返回

List[Dict]

一个字典列表，每个字典包含模型预测的批次中每个图像的分数、标签和框。

将 DeformableDetrForObjectDetection 的原始输出转换为最终的边界框，格式为 (左上角 x 坐标, 左上角 y 坐标, 右下角 x 坐标, 右下角 y 坐标)。仅支持 PyTorch。

DeformableDetrConfig

class transformers.DeformableDetrConfig

<来源>

( use_timm_backbone = True backbone_config = None num_channels = 3 num_queries = 300 max_position_embeddings = 1024 encoder_layers = 6 encoder_ffn_dim = 1024 encoder_attention_heads = 8 decoder_layers = 6 decoder_ffn_dim = 1024 decoder_attention_heads = 8 encoder_layerdrop = 0.0 is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 init_xavier_std = 1.0 return_intermediate = True auxiliary_loss = False position_embedding_type = 'sine' backbone = 'resnet50' use_pretrained_backbone = True dilation = False num_feature_levels = 4 encoder_n_points = 4 decoder_n_points = 4 two_stage = False two_stage_num_proposals = 300 with_box_refine = False class_cost = 1 bbox_cost = 5 giou_cost = 2 mask_loss_coefficient = 1 dice_loss_coefficient = 1 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 eos_coefficient = 0.1 focal_alpha = 0.25 disable_custom_kernels = False **kwargs )

参数

• use_timm_backbone (bool, optional, defaults to True) — 是否使用 timm 库作为骨干网络。如果设置为 False，将使用 AutoBackbone API。
• backbone_config (PretrainedConfig or dict, optional) — 骨干模型的配置。仅在 use_timm_backbone 设置为 False 时使用，此时默认为 ResNetConfig()。
• num_channels (int, optional, defaults to 3) — 输入通道数。
• num_queries (int, optional, defaults to 300) — 对象查询的数量，即检测槽位。这是 DeformableDetrModel 在单个图像中可以检测到的对象的最大数量。如果将 two_stage 设置为 True，则使用 two_stage_num_proposals。
• d_model (int, optional, defaults to 256) — 层的维度。
• encoder_layers (int, optional, defaults to 6) — 编码器层数。
• decoder_layers (int, optional, defaults to 6) — 解码器层数。
• encoder_attention_heads (int, optional, defaults to 8) — Transformer 编码器中每个注意力层的注意力头数。
• decoder_attention_heads (int, optional, defaults to 8) — Transformer 解码器中每个注意力层的注意力头数。
• decoder_ffn_dim (int, optional, defaults to 1024) — 解码器中“中间”（通常称为前馈）层的维度。
• encoder_ffn_dim (int, optional, defaults to 1024) — 解码器中“中间”（通常称为前馈）层的维度。
• activation_function (str or function, optional, defaults to "relu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
• dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢失概率。
• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢失比率。
• activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的丢失比率。
• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• init_xavier_std (float, optional, defaults to 1) — 用于 HM Attention map 模块中的 Xavier 初始化增益的缩放因子。
• encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。
• auxiliary_loss (bool, optional, defaults to False) — 是否使用辅助解码损失（每个解码器层的损失）。
• position_embedding_type (str, optional, defaults to "sine") — 在图像特征之上使用的位置嵌入类型。其中之一是 "sine" 或 "learned"。
• backbone (str, optional, defaults to "resnet50") — 在 use_timm_backbone = True 时要使用的卷积骨干的名称。支持来自 timm 包的任何卷积骨干。有关所有可用模型的列表，请参见此页面。
• use_pretrained_backbone (bool, optional, defaults to True) — 是否对骨干网络使用预训练权重。仅在 use_timm_backbone = True 时支持。
• dilation (bool, optional, defaults to False) — 是否在最后一个卷积块（DC5）中用膨胀替换步幅。仅在 use_timm_backbone = True 时支持。
• class_cost (float, optional, defaults to 1) — 匈牙利匹配成本中分类错误的相对权重。
• bbox_cost (float, optional, defaults to 5) — 匈牙利匹配成本中边界框坐标的 L1 误差的相对权重。
• giou_cost (float, optional, defaults to 2) — 匈牙利匹配成本中边界框广义 IoU 损失的相对权重。
• mask_loss_coefficient (float, optional, defaults to 1) — 全景分割损失中焦点损失的相对权重。
• dice_loss_coefficient (float, optional, defaults to 1) — DICE/F-1 损失在全景分割损失中的相对权重。
• bbox_loss_coefficient (float, optional, defaults to 5) — 目标检测损失中 L1 边界框损失的相对权重。
• giou_loss_coefficient (float, optional, defaults to 2) — 目标检测损失中广义 IoU 损失的相对权重。
• eos_coefficient (float, optional, defaults to 0.1) — 目标检测损失中“无对象”类的相对分类权重。
• num_feature_levels (int, optional, defaults to 4) — 输入特征级别的数量。
• encoder_n_points (int, optional, defaults to 4) — 编码器中每个注意力头的每个特征级别中采样的键的数量。
• decoder_n_points (int, optional, defaults to 4) — 解码器中每个注意力头的每个特征级别中采样的键的数量。
• two_stage (bool, optional, defaults to False) — 是否应用两阶段可变形 DETR，其中区域提议也由 Deformable DETR 的变体生成，并进一步输入解码器进行迭代边界框细化。
• two_stage_num_proposals (int, optional, defaults to 300) — 要生成的区域提议数量，如果two_stage设置为True。
• with_box_refine (bool, optional, defaults to False) — 是否应用迭代边界框细化，其中每个解码器层根据前一层的预测细化边界框。
• focal_alpha (float, optional, defaults to 0.25) — 焦点损失中的 Alpha 参数。
• disable_custom_kernels (bool, optional, defaults to False) — 禁用自定义 CUDA 和 CPU 内核的使用。这个选项对 ONNX 导出是必要的，因为 PyTorch ONNX 导出不支持自定义内核。

这是用于存储 DeformableDetrModel 配置的配置类。根据指定的参数实例化 Deformable DETR 模型，定义模型架构。使用默认值实例化配置将产生类似于 Deformable DETR SenseTime/deformable-detr架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import DeformableDetrConfig, DeformableDetrModel

>>> # Initializing a Deformable DETR SenseTime/deformable-detr style configuration
>>> configuration = DeformableDetrConfig()

>>> # Initializing a model (with random weights) from the SenseTime/deformable-detr style configuration
>>> model = DeformableDetrModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

DeformableDetrModel

class transformers.DeformableDetrModel

< source >

( config: DeformableDetrConfig )

参数

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

裸的 Deformable DETR 模型（由骨干和编码器-解码器 Transformer 组成），输出没有特定头部的原始隐藏状态。

此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。 像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参见 DeformableDetrImageProcessor.call()。
• pixel_mask (torch.LongTensor of shape (batch_size, height, width), optional) — 避免在填充像素值上执行注意力的蒙版。蒙版值选择在[0, 1]范围内：
  • 对于真实像素为 1（即not masked），
  • 对于填充的像素为 0（即masked）。

  什么是注意力蒙版？

• decoder_attention_mask (torch.FloatTensor of shape (batch_size, num_queries), optional) — 默认情况下不使用。可用于屏蔽对象查询。
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括(last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional)是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递图像的扁平化表示，而不是传递扁平化特征图（骨干网络输出 + 投影层输出）。
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是使用零张量初始化查询。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrModelOutput 或 tuple(torch.FloatTensor)

一个transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False，则包含根据配置（DeformableDetrConfig）和输入的各种元素。

• init_reference_points (torch.FloatTensor of shape (batch_size, num_queries, 4)) — 通过 Transformer 解码器发送的初始参考点。
• last_hidden_state (torch.FloatTensor of shape (batch_size, num_queries, hidden_size)) — 模型解码器最后一层的输出中的隐藏状态序列。
• intermediate_hidden_states (torch.FloatTensor，形状为(batch_size, config.decoder_layers, num_queries, hidden_size)) — 堆叠的中间隐藏状态（解码器每层的输出）。
• intermediate_reference_points (torch.FloatTensor，形状为(batch_size, config.decoder_layers, num_queries, 4)) — 堆叠的中间参考点（解码器每层的参考点）。
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 每个层的形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor元组。解码器在每个层的输出加上初始嵌入输出的隐藏状态。
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 每个层的形状为(batch_size, num_heads, num_queries, num_queries)的torch.FloatTensor元组。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 每个层的形状为(batch_size, num_queries, num_heads, 4, 4)的torch.FloatTensor元组。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 每个层的形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器在每个层的输出加上初始嵌入输出的隐藏状态。
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 每个层的形状为(batch_size, num_queries, num_heads, 4, 4)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• enc_outputs_class (torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)，optional，当config.with_box_refine=True和config.two_stage=True时返回) — 预测的边界框分数，第一阶段选择前config.two_stage_num_proposals个得分最高的边界框作为区域提议。边界框二元分类的输出（即前景和背景）。
• enc_outputs_coord_logits (torch.FloatTensor，形状为(batch_size, sequence_length, 4)，optional，当config.with_box_refine=True和config.two_stage=True时返回) — 第一阶段预测的边界框坐标的 logits。

DeformableDetrModel 的 forward 方法，覆盖了__call__特殊方法。

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

示例:

>>> from transformers import AutoImageProcessor, DeformableDetrModel
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("SenseTime/deformable-detr")
>>> model = DeformableDetrModel.from_pretrained("SenseTime/deformable-detr")

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]

DeformableDetrForObjectDetection

class transformers.DeformableDetrForObjectDetection

< source >

( config: DeformableDetrConfig )

参数

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

Deformable DETR 模型（由骨干和编码器-解码器 Transformer 组成），顶部带有目标检测头，用于诸如 COCO 检测的任务。

这个模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrObjectDetectionOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。 像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 DeformableDetrImageProcessor.call()。
• pixel_mask (torch.LongTensor，形状为(batch_size, height, width)，可选) — 用于避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]中。
  • 1 表示真实像素（即未屏蔽），
  • 0 表示填充像素（即masked）。

  什么是注意力掩码？

• decoder_attention_mask (torch.FloatTensor，形状为(batch_size, num_queries)，可选) — 默认情况下不使用。可用于屏蔽对象查询。
• encoder_outputs (tuple(tuple(torch.FloatTensor)，可选) — 元组包含(last_hidden_state，可选: hidden_states，可选: attentions)，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递扁平化的特征图（骨干+投影层的输出），而不是传递图像的扁平化表示。
• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, num_queries, hidden_size)，可选) — 可选地，可以直接传递嵌入表示，而不是使用零张量初始化查询。
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
• labels (List[Dict] of len (batch_size,), optional) — 用于计算二部匹配损失的标签。字典列表，每个字典至少包含以下 2 个键：‘class_labels’和’boxes’（分别是批处理中图像的类标签和边界框）。类标签本身应该是长度为(图像中边界框的数量,)的torch.LongTensor，而边界框应该是形状为(图像中边界框的数量, 4)的torch.FloatTensor。

返回

transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrObjectDetectionOutput 或 tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 作为负对数似然（交叉熵）和边界框损失的线性组合的总损失。后者被定义为 L1 损失和广义比例不变 IoU 损失的线性组合。
• loss_dict (Dict, optional) — 包含各个损失的字典。用于记录日志。
• logits (torch.FloatTensor of shape (batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。
• pred_boxes (torch.FloatTensor of shape (batch_size, num_queries, 4)) — 所有查询的规范化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内进行了规范化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用~DeformableDetrProcessor.post_process_object_detection来检索未规范化的边界框。
• auxiliary_outputs (list[Dict], optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。这是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。
• last_hidden_state (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 模型解码器最后一层的隐藏状态序列。
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个元组，包含形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor（一个用于嵌入输出，一个用于每层输出）。解码器在每层输出的隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 一个元组，包含形状为(batch_size, num_heads, num_queries, num_queries)的torch.FloatTensor（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 一个元组，包含形状为(batch_size, num_queries, num_heads, 4, 4)的torch.FloatTensor（每层一个）。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size). Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.
• encoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, sequence_length, num_heads, 4, 4). Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the self-attention heads.
• intermediate_hidden_states (torch.FloatTensor of shape (batch_size, config.de

DeiT

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

概述

DeiT 模型是由 Hugo Touvron、Matthieu Cord、Matthijs Douze、Francisco Massa、Alexandre Sablayrolles、Hervé Jégou 在通过注意力进行数据高效图像变换器训练和蒸馏中提出的。Vision Transformer（ViT）是由Dosovitskiy 等人，2020引入的，它表明可以使用 Transformer 编码器（类似 BERT）匹配甚至超越现有的卷积神经网络。然而，该论文中介绍的 ViT 模型需要在昂贵的基础设施上进行多周的训练，使用外部数据。DeiT（数据高效图像变换器）是更高效的用于图像分类的训练变换器，与原始 ViT 模型相比，需要更少的数据和更少的计算资源。

论文摘要如下：

最近，纯基于注意力的神经网络被证明可以解决图像理解任务，如图像分类。然而，这些视觉变换器是使用昂贵的基础设施对数亿张图像进行预训练的，从而限制了它们的采用。在这项工作中，我们通过仅在 Imagenet 上进行训练，制作了一款竞争力强的无卷积变换器。我们在不到 3 天的时间内在一台计算机上对它们进行训练。我们的参考视觉变换器（8600 万参数）在 ImageNet 上的单裁剪评估中实现了 83.1%的 top-1 准确率，没有使用外部数据。更重要的是，我们引入了一种特定于变换器的师生策略。它依赖于一个蒸馏标记，确保学生通过注意力从老师那里学习。我们展示了基于这种基于标记的蒸馏的兴趣，特别是在使用卷积网络作为老师时。这使我们能够报告与卷积网络在 Imagenet 上竞争的结果（我们的准确率高达 85.2%），以及在转移到其他任务时。我们分享我们的代码和模型。

该模型由nielsr贡献。该模型的 TensorFlow 版本由amyeroberts添加。

使用提示

• 与 ViT 相比，DeiT 模型使用所谓的蒸馏标记来有效地从老师那里学习（在 DeiT 论文中，老师是类似 ResNet 的模型）。通过自注意力层，蒸馏标记通过与类（[CLS]）和补丁标记的交互进行反向传播学习。
• 对蒸馏模型进行微调有两种方式，要么（1）采用传统方式，只在类标记的最终隐藏状态上放置一个预测头，不使用蒸馏信号，要么（2）在类标记和蒸馏标记的顶部都放置一个预测头。在这种情况下，[CLS]预测头使用预测头和地面真实标签之间的常规交叉熵进行训练，而蒸馏预测头使用硬蒸馏进行训练（蒸馏头的预测和教师预测的标签之间的交叉熵）。在推理时，将两个头之间的平均预测作为最终预测。（2）也被称为“蒸馏微调”，因为依赖于已经在下游数据集上进行微调的教师。在模型方面，（1）对应于 DeiTForImageClassification，（2）对应于 DeiTForImageClassificationWithTeacher。
• 请注意，作者们还尝试了对（2）进行软蒸馏（在这种情况下，蒸馏预测头使用 KL 散度进行训练，以匹配老师的 softmax 输出），但硬蒸馏效果最好。
• 所有发布的检查点仅在 ImageNet-1k 上进行了预训练和微调。没有使用外部数据。这与原始的 ViT 模型形成对比，原始的 ViT 模型使用了外部数据，如 JFT-300M 数据集/Imagenet-21k 进行预训练。
• DeiT 的作者还发布了更高效训练的 ViT 模型，您可以直接插入 ViTModel 或 ViTForImageClassification。为了模拟在一个更大的数据集上训练（仅使用 ImageNet-1k 进行预训练），使用了数据增强、优化和正则化等技术。有 4 个变体可用（3 种不同大小）：facebook/deit-tiny-patch16-224、facebook/deit-small-patch16-224、facebook/deit-base-patch16-224和facebook/deit-base-patch16-384。请注意，应该使用 DeiTImageProcessor 来为模型准备图像。

资源

一系列官方 Hugging Face 和社区（由🌎表示）资源，可帮助您开始使用 DeiT。

图像分类

• DeiTForImageClassification 由这个示例脚本和笔记本支持。
• 参见：图像分类任务指南

此外：

• DeiTForMaskedImageModeling 由这个示例脚本支持。

如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将对其进行审查！资源应该理想地展示一些新东西，而不是重复现有资源。

DeiTConfig

class transformers.DeiTConfig

<来源>

( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = 224 patch_size = 16 num_channels = 3 qkv_bias = True encoder_stride = 16 **kwargs )

参数

• hidden_size（int，可选，默认为 768）— 编码器层和池化层的维度。
• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数量。
• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size（int，可选，默认为 3072）— Transformer 编码器中“中间”（即前馈）层的维度。
• hidden_act（str或function，可选，默认为"gelu"）— 编码器和池化层中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• hidden_dropout_prob（float，可选，默认为 0.0）— 嵌入层、编码器和池化层中所有全连接层的丢失概率。
• attention_probs_dropout_prob（float，可选，默认为 0.0）— 注意力概率的丢失比率。
• initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps（float，可选，默认为 1e-12）— 层归一化层使用的 epsilon。
• image_size（int，可选，默认为 224）— 每个图像的大小（分辨率）。
• patch_size（int，可选，默认为 16）— 每个补丁的大小（分辨率）。
• num_channels（int，可选，默认为 3）— 输入通道的数量。
• qkv_bias（bool，可选，默认为True）— 是否为查询、键和值添加偏置。
• encoder_stride (int, optional, 默认为 16) — 用于在解码器头部增加空间分辨率的因子，用于遮蔽图像建模。

这是一个配置类，用于存储 DeiTModel 的配置。它用于根据指定的参数实例化一个 DeiT 模型，定义模型架构。使用默认值实例化配置将产生类似于 DeiT facebook/deit-base-distilled-patch16-224 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import DeiTConfig, DeiTModel

>>> # Initializing a DeiT deit-base-distilled-patch16-224 style configuration
>>> configuration = DeiTConfig()

>>> # Initializing a model (with random weights) from the deit-base-distilled-patch16-224 style configuration
>>> model = DeiTModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

DeiTFeatureExtractor

class transformers.DeiTFeatureExtractor

< source >

( *args **kwargs )

__call__

< source >

( images **kwargs )

预处理图像或一批图像。

DeiTImageProcessor

class transformers.DeiTImageProcessor

< source >

( do_resize: bool = True size: Dict = None resample: Resampling = 3 do_center_crop: bool = True crop_size: Dict = None rescale_factor: Union = 0.00392156862745098 do_rescale: bool = True do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

• do_resize (bool, optional, 默认为 True) — 是否将图像的 (height, width) 尺寸调整为指定的 size。可以被 preprocess 中的 do_resize 覆盖。
• size (Dict[str, int] optional, 默认为 {"height" -- 256, "width": 256}): resize 后的图像尺寸。可以被 preprocess 中的 size 覆盖。
• resample (PILImageResampling 过滤器, optional, 默认为 Resampling.BICUBIC) — 如果调整图像大小，要使用的重采样滤波器。可以被 preprocess 中的 resample 覆盖。
• do_center_crop (bool, optional, 默认为 True) — 是否对图像进行中心裁剪。如果输入尺寸在任一边小于 crop_size，则图像将用 0 填充，然后进行中心裁剪。可以被 preprocess 中的 do_center_crop 覆盖。
• crop_size (Dict[str, int], optional, 默认为 {"height" -- 224, "width": 224}): 应用中心裁剪时的期望输出尺寸。可以被 preprocess 中的 crop_size 覆盖。
• rescale_factor (int 或 float, optional, 默认为 1/255) — 如果重新缩放图像，要使用的缩放因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
• do_rescale (bool, optional, 默认为 True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
• do_normalize (bool, optional, 默认为 True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。
• image_mean (float 或 List[float], optional, 默认为 IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，要使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。
• image_std (float 或 List[float], optional, 默认为 IMAGENET_STANDARD_STD) — 如果对图像进行归一化，要使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

构建一个 DeiT 图像处理器。

preprocess

< source >

( images: Union do_resize: bool = None size: Dict = None resample = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像。期望单个图像或图像批次，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• do_resize (bool, optional, 默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], optional, 默认为 self.size) — resize 后的图像大小。
• resample (PILImageResampling, optional, 默认为 self.resample) — 如果调整图像大小，则使用的 PILImageResampling 过滤器。仅在 do_resize 设置为 True 时有效。
• do_center_crop (bool, optional, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int], optional, 默认为 self.crop_size) — 居中裁剪后的图像大小。如果图像的一条边小于 crop_size，则将用零填充，然后裁剪。
• do_rescale (bool, optional, 默认为 self.do_rescale) — 是否将图像值重新缩放到 [0 - 1] 之间。
• rescale_factor (float, optional, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。
• do_normalize (bool, optional, 默认为 self.do_normalize) — 是否对图像进行归一化。
• image_mean (float 或 List[float], optional, 默认为 self.image_mean) — 图像均值。
• image_std (float 或 List[float], optional, 默认为 self.image_std) — 图像标准差。
• return_tensors (str 或 TensorType, optional) — 要返回的张量类型。可以是以下之一：
  • None: 返回一个 np.ndarray 列表。
  • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批次。
  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批次。
  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批次。
  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批次。
• data_format (ChannelDimension 或 str, optional, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • ChannelDimension.FIRST: 图像以 (num_channels, height, width) 格式。
  • ChannelDimension.LAST: 图像以 (height, width, num_channels) 格式。
• input_data_format (ChannelDimension 或 str, optional) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST: 图像以 (num_channels, height, width) 格式。
  • "channels_last" 或 ChannelDimension.LAST: 图像以 (height, width, num_channels) 格式。
  • "none" 或 ChannelDimension.NONE: 图像以 (height, width) 格式。

预处理图像或图像批次。

PytorchHide Pytorch content

DeiTModel

class transformers.DeiTModel

< source >

( config: DeiTConfig add_pooling_layer: bool = True use_mask_token: bool = False )

参数

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

裸 DeiT 模型变换器输出原始隐藏状态，没有特定的顶部头。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

< source >

( pixel_values: Optional = None bool_masked_pos: Optional = None head_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)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DeiTImageProcessor.call()。
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在 [0, 1]：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• bool_masked_pos (torch.BoolTensor of shape (batch_size, num_patches), optional) — 布尔掩码位置。指示哪些补丁被遮蔽（1）哪些没有（0）。

返回

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

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

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

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

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

示例：

>>> from transformers import AutoImageProcessor, DeiTModel
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTModel.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 198, 768]

DeiTForMaskedImageModeling

class transformers.DeiTForMaskedImageModeling

< source >

( config: DeiTConfig )

参数

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

带有顶部解码器的 DeiT 模型，用于遮罩图像建模，如SimMIM中提出的。

请注意，我们在我们的示例目录中提供了一个脚本，用于在自定义数据上预训练此模型。

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

forward

< source >

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 DeiTImageProcessor.call()。
• 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 而不是一个普通的元组。
• bool_masked_pos (torch.BoolTensor，形状为(batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被掩盖（1）哪些没有（0）。

返回

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

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

• loss (torch.FloatTensor，形状为(1,)，optional，当提供bool_masked_pos时返回) — 重建损失。
• reconstruction (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 重建/完成的图像。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True时返回
• when 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时返回
• config.output_attentions=True): 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组（每层一个）。自注意力头中的注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, DeiTForMaskedImageModeling
>>> import torch
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForMaskedImageModeling.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 224, 224]

DeiTForImageClassification

class transformers.DeiTForImageClassification

< source >

( config: DeiTConfig )

参数

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

带有图像分类头部的 DeiT 模型变换器（在[CLS]标记的最终隐藏状态之上的线性层），例如用于 ImageNet。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

< source >

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

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DeiTImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]范围内：
  • 1 表示头部未被masked，
  • 0 表示头部是masked。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 分类（如果config.num_labels==1则为回归）损失。
• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）— 分类（如果config.num_labels==1则为回归）分数（SoftMax 之前）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。模型在每个阶段的输出的隐藏状态（也称为特征图）。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组。 自注意力头中用于计算加权平均值的注意力权重在注意力 softmax 之后。

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

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

示例：

>>> from transformers import AutoImageProcessor, DeiTForImageClassification
>>> import torch
>>> from PIL import Image
>>> import requests

>>> torch.manual_seed(3)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # note: we are loading a DeiTForImageClassificationWithTeacher from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # 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: magpie

DeiTForImageClassificationWithTeacher

class transformers.DeiTForImageClassificationWithTeacher

<来源>

( config: DeiTConfig )

参数

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

DeiT 模型变压器，顶部带有图像分类头（在[CLS]令牌的最终隐藏状态顶部有一个线性层，在蒸馏令牌的最终隐藏状态顶部有一个线性层），例如用于 ImageNet。

… 警告::

这个模型仅支持推理。尚不支持使用蒸馏（即使用教师）进行微调。

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

forward

<来源>

( pixel_values: 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.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 DeiTImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：
  • 1 表示头部未被遮蔽，
  • 0 表示头部是masked。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutput或tuple(torch.FloatTensor)

一个transformers.models.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（DeiTConfig）和输入。

• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）- 预测分数，作为cls_logits和蒸馏logits的平均值。
• cls_logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）- 分类头部的预测分数（即类令牌最终隐藏状态顶部的线性层）。
• distillation_logits（形状为(batch_size, config.num_labels)的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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, DeiTForImageClassificationWithTeacher
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat

TensorFlow 隐藏 TensorFlow 内容

TFDeiTModel

class transformers.TFDeiTModel

<来源>

( config: DeiTConfig add_pooling_layer: bool = True use_mask_token: bool = False **kwargs )

参数

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

裸 DeiT 模型变压器输出原始隐藏状态，没有特定头部。此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规 TensorFlow 模块，并参考 TensorFlow 文档以获取有关一般用法和行为的所有相关信息。

call

<来源>

( pixel_values: tf.Tensor | None = None bool_masked_pos: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的tf.Tensor）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参见 DeiTImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的tf.Tensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（DeiTConfig）和输入的各种元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。
• pooler_output（形状为(batch_size, hidden_size)的tf.Tensor）— 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。 这个输出通常不是输入的语义内容的好摘要，通常最好对整个输入序列的隐藏状态进行平均或池化。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（嵌入输出的一个+每层输出的一个）。 模型在每一层输出的隐藏状态以及初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFDeiTModel
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTModel.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(image, return_tensors="tf")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 198, 768]

TFDeiTForMaskedImageModeling

class transformers.TFDeiTForMaskedImageModeling

<来源>

( config: DeiTConfig )

参数

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

DeiT 模型在顶部带有解码器，用于遮蔽图像建模，如 SimMIM 中提出的。此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规 TensorFlow 模块，并参考 TensorFlow 文档以获取有关一般用法和行为的所有相关信息。

call

< source >

( pixel_values: tf.Tensor | None = None bool_masked_pos: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedImageModelingOutput or tuple(tf.Tensor)

参数

• pixel_values (tf.Tensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DeiTImageProcessor.call()。
• head_mask (tf.Tensor of shape (num_heads,) or (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 而不是普通元组。
• bool_masked_pos (tf.Tensor of type bool and shape (batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被遮蔽（1）哪些没有（0）。

返回

transformers.modeling_tf_outputs.TFMaskedImageModelingOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedImageModelingOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（DeiTConfig）和输入的各种元素。

• loss (tf.Tensor of shape (1,), optional, returned when bool_masked_pos is provided) — Reconstruction loss.
• reconstruction (tf.Tensor of shape (batch_size, num_channels, height, width)) — 重建/完成的图像。
• hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when
• config.output_hidden_states=True): tf.Tensor 元组（如果模型具有嵌入层，则一个用于嵌入的输出 + 一个用于每个阶段的输出）的形状为 (batch_size, sequence_length, hidden_size)。模型在每个阶段输出的隐藏状态（也称为特征图）。
• attentions (tuple(tf.Tensor), optional, 当传递 output_attentions=True 或
• config.output_attentions=True): tf.Tensor 元组（每个层一个）的形状为 (batch_size, num_heads, patch_size, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFDeiTForMaskedImageModeling
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForMaskedImageModeling.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="tf").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = tf.cast(tf.random.uniform((1, num_patches), minval=0, maxval=2, dtype=tf.int32), tf.bool)

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 224, 224]

TFDeiTForImageClassification

class transformers.TFDeiTForImageClassification

<来源>

( config: DeiTConfig )

参数

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

DeiT 模型变压器，顶部带有图像分类头部（在 [CLS] 标记的最终隐藏状态之上的线性层），例如用于 ImageNet。

此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规 TensorFlow 模块，并参考 TensorFlow 文档以获取与一般用法和行为相关的所有事项。

call

<来源>

( pixel_values: tf.Tensor | None = None head_mask: tf.Tensor | None = None labels: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFImageClassifierOutput or tuple(tf.Tensor)

参数

• pixel_values（形状为 (batch_size, num_channels, height, width) 的 tf.Tensor）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DeiTImageProcessor.call()。
• head_mask（形状为 (num_heads,) 或 (num_layers, num_heads) 的 tf.Tensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值选定在 [0, 1] 范围内：
  • 1 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的 attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的 hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
• labels（形状为 (batch_size,) 的 tf.Tensor，可选）— 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_tf_outputs.TFImageClassifierOutput 或 tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFImageClassifierOutput 或 tuple(tf.Tensor)（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含各种元素，取决于配置（DeiTConfig）和输入。

• loss（形状为 (1,) 的 tf.Tensor，可选，当提供 labels 时返回）— 分类（或如果 config.num_labels==1 则为回归）损失。
• logits（形状为 (batch_size, config.num_labels) 的 tf.Tensor）— 分类（或如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（如果模型具有嵌入层的输出，则为嵌入的输出+每个阶段的输出）。模型在每个阶段的输出的隐藏状态（也称为特征图）。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, patch_size, sequence_length)的tf.Tensor元组（每层一个）。 注意权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

TFDeiTForImageClassification 前向方法，覆盖__call__特殊方法。

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

示例：

>>> from transformers import AutoImageProcessor, TFDeiTForImageClassification
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests

>>> tf.keras.utils.set_random_seed(3)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # note: we are loading a TFDeiTForImageClassificationWithTeacher from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = tf.math.argmax(logits, axis=-1)[0]
>>> print("Predicted class:", model.config.id2label[int(predicted_class_idx)])
Predicted class: little blue heron, Egretta caerulea

TFDeiTForImageClassificationWithTeacher

class transformers.TFDeiTForImageClassificationWithTeacher

<来源>

( config: DeiTConfig )

参数

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

DeiT 模型变压器，顶部带有图像分类头（在[CLS]令牌的最终隐藏状态顶部有一个线性层，在蒸馏令牌的最终隐藏状态顶部有一个线性层），例如用于 ImageNet。

… 警告::

此模型仅支持推断。尚不支持使用蒸馏（即与教师一起）进行微调。

此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规的 TensorFlow 模块，并参考 TensorFlow 文档以获取有关一般用法和行为的所有相关信息。

call

<来源>

( pixel_values: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutput or tuple(tf.Tensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的tf.Tensor）- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DeiTImageProcessor.call()。
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的tf.Tensor，可选）- 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutput或tuple(tf.Tensor)

一个transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutput或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（DeiTConfig）和输入的不同元素。

• logits（形状为(batch_size, config.num_labels)的tf.Tensor）- 预测分数，作为 cls_logits 和 distillation logits 的平均值。
• cls_logits（形状为(batch_size, config.num_labels)的tf.Tensor）- 分类头部的预测分数（即在类令牌的最终隐藏状态之上的线性层）。
• distillation_logits（形状为(batch_size, config.num_labels)的tf.Tensor）- 蒸馏头部的预测分数（即在蒸馏令牌的最终隐藏状态之上的线性层）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组。模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, TFDeiTForImageClassificationWithTeacher
>>> import tensorflow as tf
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(image, return_tensors="tf")
>>> logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = int(tf.math.argmax(logits, axis=-1))
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat

DETA

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/deta

概述

DETA 模型是由 Jeffrey Ouyang-Zhang、Jang Hyun Cho、Xingyi Zhou、Philipp Krähenbühl 在NMS Strikes Back中提出的。DETA（Detection Transformers with Assignment）通过将传统检测器中使用的一对一二部匹配损失替换为使用非极大值抑制（NMS）的一对多标签分配来改进 Deformable DETR，从而实现了高达 2.5 mAP 的显着增益。

论文摘要如下：

检测变换器（DETR）在训练期间通过一对一的二部匹配直接将查询转换为唯一对象，并实现端到端的目标检测。最近，这些模型在 COCO 上超越了传统的检测器，具有不可否认的优雅。然而，它们在多个设计方面与传统检测器不同，包括模型架构和训练计划，因此一对一匹配的有效性尚未完全理解。在这项工作中，我们在 DETR 中进行了一项严格的比较，与传统检测器中的一对多标签分配相比，传统检测器使用非极大值抑制（NMS）。令人惊讶的是，我们观察到在相同设置下，NMS 中的一对多分配始终优于标准的一对一匹配，获得了高达 2.5 mAP 的显着增益。我们的检测器使用传统的 IoU-based 标签分配训练 Deformable-DETR，在 ResNet50 骨干网络下在 12 个时期（1x 计划）内实现了 50.2 的 COCO mAP，优于此设置中的所有现有传统或基于变换器的检测器。在多个数据集、计划和架构上，我们始终表明二部匹配对于高性能检测变换器是不必要的。此外，我们将检测变换器的成功归因于其富有表现力的变换器架构。

图示

DETA 概述。摘自原始论文。

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

资源

一个官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 DETA。

• DETA 的演示笔记本可以在这里找到。
• 另请参阅：目标检测任务指南

如果您有兴趣提交资源以包含在这里，请随时打开一个 Pull Request，我们将进行审查！资源应该理想地展示一些新东西，而不是复制现有资源。

DetaConfig

class transformers.DetaConfig

<来源>

( backbone_config = None num_queries = 900 max_position_embeddings = 2048 encoder_layers = 6 encoder_ffn_dim = 2048 encoder_attention_heads = 8 decoder_layers = 6 decoder_ffn_dim = 1024 decoder_attention_heads = 8 encoder_layerdrop = 0.0 is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 init_xavier_std = 1.0 return_intermediate = True auxiliary_loss = False position_embedding_type = 'sine' num_feature_levels = 5 encoder_n_points = 4 decoder_n_points = 4 two_stage = True two_stage_num_proposals = 300 with_box_refine = True assign_first_stage = True assign_second_stage = True class_cost = 1 bbox_cost = 5 giou_cost = 2 mask_loss_coefficient = 1 dice_loss_coefficient = 1 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 eos_coefficient = 0.1 focal_alpha = 0.25 **kwargs )

参数

• backbone_config（PretrainedConfig或dict，可选，默认为ResNetConfig()）—骨干模型的配置。
• num_queries（int，可选，默认为 900）—对象查询的数量，即检测槽位。这是 DetaModel 在单个图像中可以检测到的对象的最大数量。如果two_stage设置为True，则使用two_stage_num_proposals。
• d_model（int，可选，默认为 256）—层的维度。
• encoder_layers（int，可选，默认为 6）—编码器层数。
• decoder_layers（int，可选，默认为 6）—解码器层数。
• encoder_attention_heads（int，可选，默认为 8）—变换器编码器中每个注意力层的注意力头数。
• decoder_attention_heads (int, optional, defaults to 8) — Transformer 解码器中每个注意力层的注意力头数。
• decoder_ffn_dim (int, optional, defaults to 2048) — 解码器中“中间”（通常称为前馈）层的维度。
• encoder_ffn_dim (int, optional, defaults to 2048) — 解码器中“中间”（通常称为前馈）层的维度。
• activation_function (str or function, optional, defaults to "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。
• dropout (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
• activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。
• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
• init_xavier_std (float, optional, defaults to 1) — 用于 HM Attention map 模块中 Xavier 初始化增益的缩放因子。
• encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅LayerDrop paper。
• auxiliary_loss (bool, optional, defaults to False) — 是否使用辅助解码损失（每个解码器层的损失）。
• position_embedding_type (str, optional, defaults to "sine") — 用于图像特征之上的位置嵌入的类型。可以是"sine"或"learned"之一。
• class_cost (float, optional, defaults to 1) — 匈牙利匹配成本中分类错误的相对权重。
• bbox_cost (float, optional, defaults to 5) — 匈牙利匹配成本中边界框坐标的 L1 误差的相对权重。
• giou_cost (float, optional, defaults to 2) — 匈牙利匹配成本中边界框广义 IoU 损失的相对权重。
• mask_loss_coefficient (float, optional, defaults to 1) — Focal loss 在全景分割损失中的相对权重。
• dice_loss_coefficient (float, optional, defaults to 1) — 全景分割损失中 DICE/F-1 损失的相对权重。
• bbox_loss_coefficient (float, optional, defaults to 5) — 目标检测损失中 L1 边界框损失的相对权重。
• giou_loss_coefficient (float, optional, defaults to 2) — 目标检测损失中广义 IoU 损失的相对权重。
• eos_coefficient (float, optional, defaults to 0.1) — 目标检测损失中“无对象”类的相对分类权重。
• num_feature_levels (int, optional, defaults to 5) — 输入特征级别的数量。
• encoder_n_points (int, optional, defaults to 4) — 编码器中每个注意力头的每个特征级别中采样的键的数量。
• decoder_n_points (int, optional, defaults to 4) — 解码器中每个注意力头的每个特征级别中采样的键的数量。
• two_stage (bool, optional, defaults to True) — 是否应用两阶段可变形 DETR，其中区域提议也是由 DETA 的变体生成的，然后进一步馈入解码器进行迭代边界框细化。
• two_stage_num_proposals (int, optional, defaults to 300) — 要生成的区域提议数量，如果two_stage设置为True。
• with_box_refine (bool, optional, defaults to True) — 是否应用迭代边界框细化，其中每个解码器层根据前一层的预测对边界框进行细化。
• focal_alpha (float, optional, defaults to 0.25) — Focal loss 中的 Alpha 参数。
• assign_first_stage (bool, optional, defaults to True) — 如果重叠大于阈值 0.7，则将每个预测 i 分配给最高重叠的地面真实对象。
• assign_second_stage (bool, optional, defaults to True) — 是否在第二阶段紧随第一阶段分配程序进行第二次分配。

这是一个配置类，用于存储 DetaModel 的配置。它用于根据指定的参数实例化一个 DETA 模型，定义模型架构。使用默认值实例化配置将产生与 DETA SenseTime/deformable-detr 架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import DetaConfig, DetaModel

>>> # Initializing a DETA SenseTime/deformable-detr style configuration
>>> configuration = DetaConfig()

>>> # Initializing a model (with random weights) from the SenseTime/deformable-detr style configuration
>>> model = DetaModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

DetaImageProcessor

class transformers.DetaImageProcessor

< source >

( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )

参数

• format (str, optional, defaults to "coco_detection") — 注释的数据格式。其中之一为"coco_detection"或“coco_panoptic”。
• do_resize (bool, optional, defaults to True) — 控制是否将图像的（高度，宽度）尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 参数覆盖。
• size (Dict[str, int] optional, defaults to {"shortest_edge" -- 800, "longest_edge": 1333}): 调整大小后的图像（高度，宽度）尺寸。可以被 preprocess 方法中的 size 参数覆盖。
• resample (PILImageResampling, optional, defaults to PILImageResampling.BILINEAR) — 如果调整图像大小，则使用的重采样滤波器。
• do_rescale (bool, optional, defaults to True) — 控制是否按指定的比例 rescale_factor 对图像进行重新缩放。可以被 preprocess 方法中的 do_rescale 参数覆盖。
• rescale_factor (int or float, optional, defaults to 1/255) — 如果重新缩放图像，则使用的比例因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。 do_normalize — 控制是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。
• image_mean (float or List[float], optional, defaults to IMAGENET_DEFAULT_MEAN) — 在归一化图像时使用的均值。可以是单个值或每个通道的值列表。可以被 preprocess 方法中的 image_mean 参数覆盖。
• image_std (float or List[float], optional, defaults to IMAGENET_DEFAULT_STD) — 在归一化图像时使用的标准差值。可以是单个值或每个通道的值列表。可以被 preprocess 方法中的 image_std 参数覆盖。
• do_pad (bool, optional, defaults to True) — 控制是否将图像填充到批处理中最大的图像并创建像素掩码。可以被 preprocess 方法中的 do_pad 参数覆盖。

构建一个可变形 DETR 图像处理器。

preprocess

< source >

( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像或图像批处理。期望单个图像或像素值范围从 0 到 255 的图像批处理。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
• annotations（List[Dict]或List[List[Dict]]，可选）- 与图像或一批图像相关联的注释列表。如果注释用于目标检测，则注释应该是一个带有以下键的字典：
  • “image_id”（int）：图像 ID。
  • “annotations”（List[Dict]）：图像的注释列表。每个注释应该是一个字典。一个图像可能没有注释，此时列表应为空。如果注释用于分割，注释应该是一个带有以下键的字典：
  • “image_id”（int）：图像 ID。
  • “segments_info”（List[Dict]）：图像的段列表。每个段应该是一个字典。一个图像可能没有段，此时列表应为空。
  • “file_name”（str）：图像的文件名。
• return_segmentation_masks（bool，可选，默认为 self.return_segmentation_masks）- 是否返回分割掩模。
• masks_path（str或pathlib.Path，可选）- 包含分割掩模的目录路径。
• do_resize（bool，可选，默认为 self.do_resize）- 是否调整图像大小。
• size（Dict[str, int]，可选，默认为 self.size）- 调整大小后的图像大小。
• resample（PILImageResampling，可选，默认为 self.resample）- 调整图像大小时使用的重采样滤波器。
• do_rescale（bool，可选，默认为 self.do_rescale）- 是否重新缩放图像。
• rescale_factor（float，可选，默认为 self.rescale_factor）- 重新缩放图像时使用的重新缩放因子。
• do_normalize（bool，可选，默认为 self.do_normalize）- 是否对图像进行归一化。
• image_mean（float或List[float]，可选，默认为 self.image_mean）- 在归一化图像时使用的均值。
• image_std（float或List[float]，可选，默认为 self.image_std）- 在归一化图像时使用的标准差。
• do_pad（bool，可选，默认为 self.do_pad）- 是否对图像进行填充。
• format（str或AnnotationFormat，可选，默认为 self.format）- 注释的格式。
• return_tensors（str或TensorType，可选，默认为 self.return_tensors）- 要返回的张量类型。如果为None，将返回图像列表。
• data_format（ChannelDimension或str，可选，默认为ChannelDimension.FIRST）- 输出图像的通道维度格式。可以是以下之一：
  • "channels_first"或ChannelDimension.FIRST：图像以（num_channels，height，width）格式。
  • "channels_last"或ChannelDimension.LAST：图像以（height，width，num_channels）格式。
  • 未设置：使用输入图像的通道维度格式。
• input_data_format（ChannelDimension或str，可选）- 输入图像的通道维度格式。如果未设置，将从输入图像中推断通道维度格式。可以是以下之一：
  • "channels_first"或ChannelDimension.FIRST：图像以（num_channels，height，width）格式。
  • "channels_last"或ChannelDimension.LAST：图像以（height，width，num_channels）格式。
  • "none"或ChannelDimension.NONE：图像以（height，width）格式。

对图像或一批图像进行预处理，以便模型可以使用。

post_process_object_detection

<来源>

( outputs threshold: float = 0.5 target_sizes: Union = None nms_threshold: float = 0.7 ) → export const metadata = 'undefined';List[Dict]

参数

• outputs（DetrObjectDetectionOutput）- 模型的原始输出。
• threshold（float，可选，默认为 0.5）- 保留目标检测预测的分数阈值。
• target_sizes（torch.Tensor或List[Tuple[int, int]]，可选）- 形状为(batch_size, 2)的张量或包含每个图像批次中目标大小（高度，宽度）的元组列表（Tuple[int, int]）。如果设置为 None，预测将不会被调整大小。
• nms_threshold（float，可选，默认为 0.7）- NMS 阈值。

返回

List[Dict]

一个字典列表，每个字典包含模型预测的批次中图像的分数、标签和框。

将 DetaForObjectDetection 的输出转换为最终的边界框，格式为(top_left_x, top_left_y, bottom_right_x, bottom_right_y)。仅支持 PyTorch。

DetaModel

class transformers.DetaModel

<来源>

( config: DetaConfig )

参数

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

裸的 DETA 模型（由骨干和编码器-解码器 Transformer 组成），输出原始隐藏状态，没有特定的头部。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deta.modeling_deta.DetaModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。 像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅AutoImageProcessor.__call__()。
• pixel_mask (torch.LongTensor，形状为(batch_size, height, width)，可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值选择在[0, 1]范围内：
  • 对于真实像素（即未屏蔽）为 1，
  • 对于填充像素（即屏蔽）为 0。

  什么是注意力掩码？

• decoder_attention_mask (torch.FloatTensor，形状为(batch_size, num_queries)，可选) — 默认情况下不使用。可用于屏蔽对象查询。
• encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 元组包含(last_hidden_state，可选：hidden_states，可选：attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递图像的扁平化表示，而不是传递扁平化特征图（骨干网络和投影层的输出）。
• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, num_queries, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是使用零张量初始化查询。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

返回值

transformers.models.deta.modeling_deta.DetaModelOutput或tuple(torch.FloatTensor)

一个transformers.models.deta.modeling_deta.DetaModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包括根据配置（DetaConfig）和输入的不同元素。

• init_reference_points（形状为(batch_size, num_queries, 4)的torch.FloatTensor）— 通过 Transformer 解码器发送的初始参考点。
• last_hidden_state（形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor）— 模型解码器最后一层的隐藏状态序列。
• intermediate_hidden_states（形状为(batch_size, config.decoder_layers, num_queries, hidden_size)的torch.FloatTensor）— 堆叠的中间隐藏状态（解码器每层的输出）。
• intermediate_reference_points（形状为(batch_size, config.decoder_layers, num_queries, 4)的torch.FloatTensor）— 堆叠的中间参考点（解码器每层的参考点）。
• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。解码器在每层输出的隐藏状态加上初始嵌入输出。
• decoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, num_queries, num_queries)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_queries, num_heads, 4, 4)的torch.FloatTensor元组（每层一个）。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。编码器在每层输出的隐藏状态加上初始嵌入输出。
• encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_queries, num_heads, 4, 4)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• enc_outputs_class（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor，可选，当config.with_box_refine=True和config.two_stage=True时返回）— 预测的边界框分数，其中选择前config.two_stage_num_proposals个得分最高的边界框作为第一阶段的区域提议。边界框二元分类的输出（即前景和背景）。
• enc_outputs_coord_logits（torch.FloatTensor，形状为(batch_size, sequence_length, 4)，可选，当config.with_box_refine=True和config.two_stage=True时返回）— 第一阶段中预测的边界框坐标的 logits。
• output_proposals（torch.FloatTensor，形状为(batch_size, sequence_length, 4)，可选，当config.two_stage=True时返回）— 在 gen_encoder_output_proposals 中提议边界框坐标的 logits。

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

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

示例：

>>> from transformers import AutoImageProcessor, DetaModel
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("jozhang97/deta-swin-large-o365")
>>> model = DetaModel.from_pretrained("jozhang97/deta-swin-large-o365", two_stage=False)

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 900, 256]

DetaForObjectDetection

class transformers.DetaForObjectDetection

<来源>

( config: DetaConfig )

参数

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

DETA 模型（由骨干和编码器-解码器 Transformer 组成），顶部带有目标检测头，用于诸如 COCO 检测之类的任务。

这个模型继承自 PreTrainedModel。查看超类文档以了解库实现的所有模型的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是 PyTorch 的torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deta.modeling_deta.DetaObjectDetectionOutput or tuple(torch.FloatTensor)

参数

• pixel_values（torch.FloatTensor，形状为(batch_size, num_channels, height, width)）— 像素值。默认情况下将忽略填充。 像素值可以使用 AutoImageProcessor 获得。查看AutoImageProcessor.__call__()以获取详细信息。
• pixel_mask（torch.LongTensor，形状为(batch_size, height, width)，可选）— 用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 1 表示真实像素（即未被掩码），
  • 0 表示填充像素（即已掩码）。

  什么是注意力掩码？

• decoder_attention_mask（torch.FloatTensor，形状为(batch_size, num_queries)，可选）— 默认情况下不使用。可用于屏蔽对象查询。
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包含（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，可以直接传递图像的扁平特征图（骨干+投影层的输出），而不是传递图像的扁平表示。
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 可选，可以选择直接传递嵌入表示，而不是用零张量初始化查询。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (List[Dict] of len (batch_size,), optional) — 用于计算二分匹配损失的标签。字典列表，每个字典至少包含以下 2 个键：‘class_labels’和’boxes’（分别是批处理中图像的类标签和边界框）。类标签本身应该是长度为(图像中边界框数量,)的torch.LongTensor，而边界框是形状为(图像中边界框数量, 4)的torch.FloatTensor。

返回

transformers.models.deta.modeling_deta.DetaObjectDetectionOutput或tuple(torch.FloatTensor)

transformers.models.deta.modeling_deta.DetaObjectDetectionOutput或torch.FloatTensor的元组（如果传递了return_dict=False或config.return_dict=False时）包括各种元素，具体取决于配置（DetaConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 总损失，作为负对数似然（交叉熵）和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
• loss_dict (Dict, optional) — 包含各个损失的字典。用于记录。
• logits (torch.FloatTensor of shape (batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。
• pred_boxes (torch.FloatTensor of shape (batch_size, num_queries, 4)) — 所有查询的标准化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内标准化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用~DetaProcessor.post_process_object_detection来检索未标准化的边界框。
• auxiliary_outputs (list[Dict], optional) — 可选，仅在辅助损失被激活时返回（即config.auxiliary_loss设置为True）并提供标签时返回。这是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。
• last_hidden_state (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 模型解码器最后一层的隐藏状态序列的输出。
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。解码器在每层输出的隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, num_queries, num_queries)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 元组的torch.FloatTensor（每一层一个）的形状为(batch_size, num_queries, num_heads, 4, 4)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)，可选） — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 元组的torch.FloatTensor（一个用于嵌入的输出 + 一个用于每一层的输出）的形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 元组的torch.FloatTensor（每一层一个）的形状为(batch_size, sequence_length, num_heads, 4, 4)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• intermediate_hidden_states (torch.FloatTensor of shape (batch_size, config.decoder_layers, num_queries, hidden_size)) — 堆叠的中间隐藏状态（解码器每一层的输出）。
• intermediate_reference_points (torch.FloatTensor of shape (batch_size, config.decoder_layers, num_queries, 4)) — 堆叠的中间参考点（解码器每一层的参考点）。
• init_reference_points (torch.FloatTensor of shape (batch_size, num_queries, 4)) — 通过 Transformer 解码器发送的初始参考点。
• enc_outputs_class (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)，可选，当config.with_box_refine=True和config.two_stage=True时返回） — 预测的边界框分数，其中选择前config.two_stage_num_proposals个得分最高的边界框作为第一阶段的区域提议。边界框二元分类的输出（即前景和背景）。
• enc_outputs_coord_logits (torch.FloatTensor of shape (batch_size, sequence_length, 4)，可选，当config.with_box_refine=True和config.two_stage=True时返回） — 第一阶段中预测的边界框坐标的 logits。
• output_proposals (torch.FloatTensor of shape (batch_size, sequence_length, 4)，可选，当config.two_stage=True时返回） — 在 gen_encoder_output_proposals 中的提议边界框坐标的 logits。

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

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

示例：

>>> from transformers import AutoImageProcessor, DetaForObjectDetection
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("jozhang97/deta-swin-large")
>>> model = DetaForObjectDetection.from_pretrained("jozhang97/deta-swin-large")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
...     0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected cat with confidence 0.683 at location [345.85, 23.68, 639.86, 372.83]
Detected cat with confidence 0.683 at location [8.8, 52.49, 316.93, 473.45]
Detected remote with confidence 0.568 at location [40.02, 73.75, 175.96, 117.33]
Detected remote with confidence 0.546 at location [333.68, 77.13, 370.12, 187.51]

DETR

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

概述

DETR 模型是由 Nicolas Carion、Francisco Massa、Gabriel Synnaeve、Nicolas Usunier、Alexander Kirillov 和 Sergey Zagoruyko 在使用变压器进行端到端目标检测中提出的。DETR 由一个卷积主干后面跟着一个编码器-解码器变压器组成，可以进行端到端的目标检测训练。它极大地简化了像 Faster-R-CNN 和 Mask-R-CNN 这样的模型的复杂性，这些模型使用区域提议、非极大值抑制程序和锚点生成等技术。此外，DETR 还可以自然地扩展到执行全景分割，只需在解码器输出之上添加一个蒙版头。

论文摘要如下：

我们提出了一种将目标检测视为直接集合预测问题的新方法。我们的方法简化了检测流程，有效地消除了许多手工设计的组件，如非极大值抑制程序或明确编码我们对任务的先验知识的锚点生成。新框架 DEtection TRansformer 或 DETR 的主要组成部分是通过二部匹配强制唯一预测的基于集合的全局损失，以及一个变压器编码器-解码器架构。给定一组固定的学习目标查询，DETR 推理对象之间的关系和全局图像上下文，直接并行输出最终的预测集。这个新模型在概念上简单，不需要专门的库，不像许多其他现代检测器。DETR 在具有挑战性的 COCO 目标检测数据集上表现出与经过充分优化的 Faster RCNN 基线相当的准确性和运行时性能。此外，DETR 可以轻松推广为以统一方式产生全景分割。我们展示它明显优于竞争基线。

这个模型是由nielsr贡献的。原始代码可以在这里找到。

DETR 的工作原理

以下是解释 DetrForObjectDetection 工作原理的 TLDR：

首先，将图像通过预训练的卷积主干（在论文中，作者使用 ResNet-50/ResNet-101）。假设我们也添加了一个批处理维度。这意味着主干的输入是一个形状为(batch_size, 3, height, width)的张量，假设图像有 3 个颜色通道（RGB）。CNN 主干输出一个新的低分辨率特征图，通常形状为(batch_size, 2048, height/32, width/32)。然后，将其投影到 DETR 变压器的隐藏维度，该维度默认为256，使用nn.Conv2D层。现在，我们有一个形状为(batch_size, 256, height/32, width/32)的张量。接下来，特征图被展平并转置，以获得形状为(batch_size, seq_len, d_model) = (batch_size, width/32*height/32, 256)的张量。因此，与 NLP 模型的一个区别是，序列长度实际上比通常更长，但d_model较小（在 NLP 中通常为 768 或更高）。

接下来，这通过编码器发送，输出相同形状的encoder_hidden_states（您可以将这些视为图像特征）。接下来，所谓的对象查询通过解码器发送。这是一个形状为(batch_size, num_queries, d_model)的张量，其中num_queries通常设置为 100，并用零初始化。这些输入嵌入是学习的位置编码，作者将其称为对象查询，类似于编码器，它们被添加到每个注意力层的输入中。每个对象查询将在图像中寻找特定对象。解码器通过多个自注意力和编码器-解码器注意力层更新这些嵌入，以输出相同形状的decoder_hidden_states：(batch_size, num_queries, d_model)。接下来，顶部添加了两个头用于对象检测：一个线性层用于将每个对象查询分类为对象或“无对象”之一，以及一个 MLP 用于预测每个查询的边界框。

该模型使用二部匹配损失进行训练：实际上我们比较每个 N = 100 个对象查询的预测类别+边界框与地面真实注释，填充到相同长度 N（因此如果图像仅包含 4 个对象，则 96 个注释将只有一个“无对象”作为类别和一个“无边界框”作为边界框）。使用匈牙利匹配算法找到每个 N 查询与每个 N 注释的最佳一对一映射。接下来，使用标准交叉熵（用于类别）和 L1 的线性组合以及广义 IoU 损失（用于边界框）来优化模型的参数。

DETR 可以自然扩展以执行全景分割（将语义分割和实例分割统一起来）。DetrForSegmentation 在 DetrForObjectDetection 的顶部添加了一个分割掩码头。掩码头可以同时训练，或者在两个步骤的过程中训练，首先训练一个 DetrForObjectDetection 模型来检测“事物”（实例）和“物品”（背景物品，如树木、道路、天空）周围的边界框，然后冻结所有权重，仅训练掩码头 25 个时代。实验上，这两种方法给出了类似的结果。请注意，为了使训练成为可能，预测框是必需的，因为匈牙利匹配是使用框之间的距离计算的。

使用提示

• DETR 使用所谓的对象查询来检测图像中的对象。查询的数量确定了单个图像中可以检测到的对象的最大数量，默认设置为 100（请参阅 DetrConfig 的参数num_queries）。请注意，最好有一些余地（在 COCO 中，作者使用了 100，而 COCO 图像中的最大对象数量约为 70）。
• DETR 的解码器并行更新查询嵌入。这与像 GPT-2 这样使用自回归解码而不是并行的语言模型不同。因此，不使用因果关注掩码。
• 在将隐藏状态投影到查询和键之前，DETR 在每个自注意力和交叉注意力层中添加位置嵌入。对于图像的位置嵌入，可以在固定正弦或学习的绝对位置嵌入之间进行选择。默认情况下，DetrConfig 的参数position_embedding_type设置为"sine"。
• 在训练期间，DETR 的作者确实发现在解码器中使用辅助损失是有帮助的，特别是为了帮助模型输出每个类别的正确对象数量。如果将 DetrConfig 的参数auxiliary_loss设置为True，则在每个解码器层之后添加预测前馈神经网络和匈牙利损失（FFN 共享参数）。
• 如果您想在跨多个节点的分布式环境中训练模型，则应该在modeling_detr.py中的DetrLoss类中更新num_boxes变量。在多个节点上训练时，应将其设置为所有节点上目标框的平均数量，可以在原始实现中看到这里。
• DetrForObjectDetection 和 DetrForSegmentation 可以使用timm 库中可用的任何卷积骨干进行初始化。例如，可以通过将 DetrConfig 的backbone属性设置为"tf_mobilenetv3_small_075"，然后使用该配置初始化模型来使用 MobileNet 骨干。
• DETR 调整输入图像的大小，使最短边至少为一定数量的像素，而最长边至多为 1333 像素。在训练时，使用尺度增强，使最短边随机设置为至少 480 像素，最多 800 像素。在推断时，最短边设置为 800。可以使用 DetrImageProcessor 为模型准备图像（以及可选的以 COCO 格式的注释）。由于这种调整大小，批处理中的图像可能具有不同的大小。DETR 通过将图像填充到批处理中的最大大小，并创建一个像素掩码来指示哪些像素是真实的/哪些是填充来解决这个问题。另外，也可以定义一个自定义的collate_fn来批处理图像，使用~transformers.DetrImageProcessor.pad_and_create_pixel_mask。
• 图像的大小将决定所使用的内存量，从而确定batch_size。建议每个 GPU 使用批量大小为 2。有关更多信息，请参阅此 Github 线程。

有三种实例化 DETR 模型的方法（取决于您的偏好）：

选项 1：使用整个模型的预训练权重实例化 DETR

>>> from transformers import DetrForObjectDetection

>>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")

选项 2：使用随机初始化的 Transformer 权重实例化 DETR，但使用骨干的预训练权重

>>> from transformers import DetrConfig, DetrForObjectDetection

>>> config = DetrConfig()
>>> model = DetrForObjectDetection(config)

选项 3：使用随机初始化的骨干+Transformer 实例化 DETR

>>> config = DetrConfig(use_pretrained_backbone=False)
>>> model = DetrForObjectDetection(config)

总之，请参考以下表格：

简而言之，应该准备数据以 COO 检测或 COO 全景格式，然后使用 DetrImageProcessor 创建pixel_values、pixel_mask和可选的labels，然后可以用于训练（或微调）模型。对于评估，应该首先使用 DetrImageProcessor 的其中一种后处理方法转换模型的输出。这些可以提供给CocoEvaluator或PanopticEvaluator，这些评估器允许您计算像平均精度（mAP）和全景质量（PQ）这样的指标。后者对象在原始存储库中实现。有关评估的更多信息，请参见示例笔记本。

资源

一个官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 DETR。

目标检测

• 所有示例笔记本说明在自定义数据集上对 DetrForObjectDetection 和 DetrForSegmentation 进行微调的示例可以在此处找到。
• 参见：目标检测任务指南

如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将进行审查！资源应该展示一些新东西，而不是重复现有资源。

DetrConfig

class transformers.DetrConfig

<来源>

( use_timm_backbone = True backbone_config = None num_channels = 3 num_queries = 100 encoder_layers = 6 encoder_ffn_dim = 2048 encoder_attention_heads = 8 decoder_layers = 6 decoder_ffn_dim = 2048 decoder_attention_heads = 8 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 init_xavier_std = 1.0 auxiliary_loss = False position_embedding_type = 'sine' backbone = 'resnet50' use_pretrained_backbone = True dilation = False class_cost = 1 bbox_cost = 5 giou_cost = 2 mask_loss_coefficient = 1 dice_loss_coefficient = 1 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 eos_coefficient = 0.1 **kwargs )

参数

• use_timm_backbone（bool，可选，默认为True）— 是否使用timm库作为骨干。如果设置为False，将使用AutoBackbone API。
• backbone_config（PretrainedConfig或dict，可选）— 骨干模型的配置。仅在use_timm_backbone设置为False时使用，默认为ResNetConfig()。
• num_channels（int，可选，默认为 3）— 输入通道的数量。
• num_queries（int，可选，默认为 100）— 对象查询的数量，即检测槽的数量。这是 DetrModel 在单个图像中可以检测的对象的最大数量。对于 COCO，我们建议使用 100 个查询。
• d_model（int，可选，默认为 256）— 层的维度。
• encoder_layers（int，可选，默认为 6）— 编码器层数。
• decoder_layers（int，可选，默认为 6）— 解码器层数。
• encoder_attention_heads（int，可选，默认为 8）— Transformer 编码器中每个注意力层的注意力头数。
• decoder_attention_heads (int, optional, defaults to 8) — Transformer 解码器中每个注意力层的注意力头数。
• decoder_ffn_dim (int, optional, defaults to 2048) — 解码器中“中间”（通常称为前馈）层的维度。
• encoder_ffn_dim (int, optional, defaults to 2048) — 解码器中“中间”（通常称为前馈）层的维度。
• activation_function (str or function, optional, defaults to "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
• activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。
• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• init_xavier_std (float, optional, defaults to 1) — 用于 HM Attention map 模块中 Xavier 初始化增益的缩放因子。
• encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。更多细节请参阅LayerDrop paper。
• decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。更多细节请参阅LayerDrop paper。
• auxiliary_loss (bool, optional, defaults to False) — 是否使用辅助解码损失（每个解码器层的损失）。
• position_embedding_type (str, optional, defaults to "sine") — 在图像特征之上使用的位置嵌入的类型。可以是"sine"或"learned"之一。
• backbone (str, optional, defaults to "resnet50") — 在use_timm_backbone = True时要使用的卷积骨干网络的名称。支持 timm 包中的任何卷积骨干网络。有关所有可用模型的列表，请参阅此页面。
• use_pretrained_backbone (bool, optional, defaults to True) — 是否在骨干网络中使用预训练权重。仅在use_timm_backbone = True时支持。
• dilation (bool, optional, defaults to False) — 是否在最后的卷积块（DC5）中用扩张替换步幅。仅在use_timm_backbone = True时支持。
• class_cost (float, optional, defaults to 1) — 匈牙利匹配成本中分类错误的相对权重。
• bbox_cost (float, optional, defaults to 5) — 相对于匈牙利匹配成本中边界框坐标的 L1 误差的权重。
• giou_cost (float, optional, defaults to 2) — 相对于匈牙利匹配成本中边界框广义 IoU 损失的权重。
• mask_loss_coefficient (float, optional, defaults to 1) — 泛光分割损失中 Focal 损失的相对权重。
• dice_loss_coefficient (float, optional, defaults to 1) — 泛光分割损失中 DICE/F-1 损失的相对权重。
• bbox_loss_coefficient (float, optional, defaults to 5) — 目标检测损失中 L1 边界框损失的相对权重。
• giou_loss_coefficient (float, optional, defaults to 2) — 目标检测损失中广义 IoU 损失的相对权重。
• eos_coefficient (float, optional, defaults to 0.1) — 目标检测损失中“无对象”类别的相对分类权重。

这是一个配置类，用于存储 DetrModel 的配置。它用于根据指定的参数实例化一个 DETR 模型，定义模型架构。使用默认值实例化配置将产生类似于 DETR facebook/detr-resnet-50架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import DetrConfig, DetrModel

>>> # Initializing a DETR facebook/detr-resnet-50 style configuration
>>> configuration = DetrConfig()

>>> # Initializing a model (with random weights) from the facebook/detr-resnet-50 style configuration
>>> model = DetrModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

from_backbone_config

< source >

( backbone_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';DetrConfig

参数

• backbone_config (PretrainedConfig) — 骨干配置。

返回

DetrConfig

配置对象的实例

从预训练的骨干模型配置实例化一个 DetrConfig（或派生类）。

DetrImageProcessor

class transformers.DetrImageProcessor

< source >

( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )

参数

• format (str, optional, 默认为"coco_detection") — 注释的数据格式。可以是"coco_detection"或“coco_panoptic”之一。
• do_resize (bool, optional, 默认为 True) — 控制是否将图像的(height, width)维度调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。
• size (Dict[str, int] optional, 默认为 {"shortest_edge" -- 800, "longest_edge": 1333}): 调整大小后的图像的(height, width)维度大小。可以被preprocess方法中的size参数覆盖。
• resample (PILImageResampling, optional, 默认为 PILImageResampling.BILINEAR) — 如果调整图像大小，则要使用的重采样滤波器。
• do_rescale (bool, optional, 默认为 True) — 控制是否按指定比例因子rescale_factor重新缩放图像。可以被preprocess方法中的do_rescale参数覆盖。
• rescale_factor (int 或 float, optional, 默认为 1/255) — 如果重新调整图像，则要使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。do_normalize — 控制是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。
• image_mean (float 或 List[float], optional, 默认为 IMAGENET_DEFAULT_MEAN) — 在归一化图像时使用的均值。可以是单个值或每个通道的值列表。可以被preprocess方法中的image_mean参数覆盖。
• image_std (float 或 List[float], optional, 默认为 IMAGENET_DEFAULT_STD) — 在归一化图像时使用的标准差值。可以是单个值或每个通道的值列表。可以被preprocess方法中的image_std参数覆盖。
• do_pad (bool, optional, 默认为 True) — 控制是否将图像填充到批处理中最大的图像并创建像素掩码。可以被preprocess方法中的do_pad参数覆盖。

构造一个 Detr 图像处理器。

preprocess

< source >

( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像或图像批次。期望单个或批量像素值范围从 0 到 255 的图像。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。
• annotations (AnnotationType or List[AnnotationType], optional) — 与图像或图像批次相关联的注释列表。如果注释是用于对象检测的，则注释应该是一个带有以下键的字典：
  • “image_id” (int): 图像 id。
  • “annotations” (List[Dict]): 图像的注释列表。每个注释应该是一个字典。一个图像可以没有注释，此时列表应为空。如果注释是用于分割的，注释应该是一个带有以下键的字典：
  • “image_id” (int): 图像 id。
  • “segments_info” (List[Dict]): 图像的段列表。每个段应该是一个字典。一个图像可以没有段，此时列表应为空。
  • “file_name” (str): 图像的文件名。
• return_segmentation_masks (bool, optional, 默认为 self.return_segmentation_masks) — 是否返回分割蒙版。
• masks_path (str or pathlib.Path, optional) — 包含分割蒙版的目录路径。
• do_resize (bool, optional, 默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], optional, 默认为 self.size) — 调整大小后的图像尺寸。
• resample (PILImageResampling, optional, 默认为 self.resample) — 调整图像大小时使用的重采样滤波器。
• do_rescale (bool, optional, 默认为 self.do_rescale) — 是否重新缩放图像。
• rescale_factor (float, optional, 默认为 self.rescale_factor) — 调整图像时使用的缩放因子。
• do_normalize (bool, optional, 默认为 self.do_normalize) — 是否规范化图像。
• image_mean (float or List[float], optional, 默认为 self.image_mean) — 在规范化图像时使用的均值。
• image_std (float or List[float], optional, 默认为 self.image_std) — 在规范化图像时使用的标准差。
• do_pad (bool, optional, 默认为 self.do_pad) — 是否填充图像。
• format (str or AnnotationFormat, optional, 默认为 self.format) — 注释的格式。
• return_tensors (str or TensorType, optional, 默认为 self.return_tensors) — 要返回的张量类型。如果为None，将返回图像列表。
• data_format (ChannelDimension or str, optional, 默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST: 图像以（通道数，高度，宽度）格式。
  • "channels_last" 或 ChannelDimension.LAST: 图像以（高度，宽度，通道数）格式。
  • 未设置：使用输入图像的通道维度格式。
• input_data_format (ChannelDimension or str, optional) — 输入图像的通道维度格式。如果未设置，将从输入图像中推断通道维度格式。可以是以下之一：
  • "channels_first" 或 ChannelDimension.FIRST: 图像以（通道数，高度，宽度）格式。
  • "channels_last" 或 ChannelDimension.LAST: 图像以（高度，宽度，通道数）格式。
  • "none" 或 ChannelDimension.NONE: 图像以（高度，宽度）格式。

预处理图像或图像批次，以便模型可以使用。

post_process_object_detection

<来源>

( outputs threshold: float = 0.5 target_sizes: Union = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (DetrObjectDetectionOutput) — 模型的原始输出。
• threshold (float, optional) — 保留对象检测预测的分数阈值。
• target_sizes (torch.Tensor或列表[元组[int, int]], 可选) — 形状为(batch_size, 2)的张量或包含每个图像的目标大小(高度，宽度)的元组列表(元组[int, int])。如果未设置，预测将不会被调整大小。

返回

列表[字典]

一个字典列表，每个字典包含模型预测的批次中图像的分数、标签和框。

将 DetrForObjectDetection 的原始输出转换为最终的边界框，格式为（左上角 _x，左上角 _y，右下角 _x，右下角 _y）。仅支持 PyTorch。

后处理语义分割

<来源>

( outputs target_sizes: List = None ) → export const metadata = 'undefined';List[torch.Tensor]

参数

• outputs (DetrForSegmentation) — 模型的原始输出。
• target_sizes (列表[元组[int, int]], 可选) — 一个元组列表(元组[int, int])，包含批次中每个图像的目标大小（高度，宽度）。如果未设置，预测将不会被调整大小。

返回

列表[torch.Tensor]

一个长度为batch_size的列表，其中每个项是一个形状为(高度，宽度)的语义分割地图，对应于目标大小条目（如果指定了target_sizes）。每个torch.Tensor的每个条目对应于一个语义类别 id。

将 DetrForSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

后处理实例分割

<来源>

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (DetrForSegmentation) — 模型的原始输出。
• threshold (float, 可选, 默认为 0.5) — 保留预测实例掩模的概率分数阈值。
• mask_threshold (float, 可选, 默认为 0.5) — 将预测的掩模转换为二进制值时使用的阈值。
• overlap_mask_area_threshold (float, 可选, 默认为 0.8) — 合并或丢弃每个二进制实例掩模中的小不连续部分的重叠掩模区域阈值。
• target_sizes (列表[元组], 可选) — 长度为(batch_size)的列表，其中每个列表项(元组[int, int]])对应于每个预测的请求最终大小(高度，宽度)。如果未设置，预测将不会被调整大小。
• return_coco_annotation (bool, 可选) — 默认为False。如果设置为True，则以 COCO 运行长度编码（RLE）格式返回分割地图。

返回

列表[字典]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation — 形状为(高度，宽度)的张量，其中每个像素代表segment_id或列表[列表]的运行长度编码（RLE）的分割地图，如果 return_coco_annotation 设置为True。如果未找到高于threshold的掩模，则设置为None。
• segments_info — 包含每个段的附加信息的字典。
  • id — 代表segment_id的整数。
  • label_id — 代表与segment_id对应的标签/语义类别 id 的整数。
  • score — 具有segment_id的段的预测分数。

将 DetrForSegmentation 的输出转换为实例分割预测。仅支持 PyTorch。

后处理全景分割

<来源>

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (DetrForSegmentation) — 来自 DetrForSegmentation 的输出。
• threshold (float, 可选, 默认为 0.5) — 保留预测实例掩模的概率分数阈值。
• mask_threshold (float, 可选, 默认为 0.5) — 在将预测的掩模转换为二进制值时使用的阈值。
• overlap_mask_area_threshold (float, 可选, 默认为 0.8) — 合并或丢弃每个二进制实例掩模中的小断开部分的重叠掩模面积阈值。
• label_ids_to_fuse (Set[int], 可选) — 此状态中的标签将使其所有实例被融合在一起。例如，我们可以说一张图像中只能有一个天空，但可以有几个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不在其中。
• target_sizes (List[Tuple], 可选) — 长度为(batch_size)的列表，其中每个列表项(Tuple[int, int]])对应于批次中每个预测的请求最终大小(高度、宽度)。如果未设置，预测将不会被调整大小。

返回

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation — 形状为(height, width)的张量，其中每个像素表示一个segment_id，如果在threshold以上找不到掩模，则表示为None。如果指定了target_sizes，则将分割调整为相应的target_sizes条目。
• segments_info — 一个包含每个段的额外信息的字典。
  • id — 代表segment_id的整数。
  • label_id — 代表与segment_id对应的标签/语义类别 id 的整数。
  • was_fused — 一个布尔值，如果label_id在label_ids_to_fuse中，则为True，否则为False。同一类别/标签的多个实例被融合并分配一个单独的segment_id。
  • score — 带有segment_id的段的预测分数。

将 DetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。

DetrFeatureExtractor

class transformers.DetrFeatureExtractor

< source >

( *args **kwargs )

__call__

< source >

( images **kwargs )

预处理一张图像或一批图像。

post_process_object_detection

< source >

( outputs threshold: float = 0.5 target_sizes: Union = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (DetrObjectDetectionOutput) — 模型的原始输出。
• threshold (float, 可选) — 保留对象检测预测的分数阈值。
• target_sizes (torch.Tensor或List[Tuple[int, int]], 可选) — 形状为(batch_size, 2)的张量或包含批次中每个图像的目标大小(height, width)的元组列表(Tuple[int, int])。如果未设置，预测将不会被调整大小。

返回

List[Dict]

一个字典列表，每个字典包含模型预测的批次中每个图像的分数、标签和框。

将 DetrForObjectDetection 的原始输出转换为(top_left_x, top_left_y, bottom_right_x, bottom_right_y)格式的最终边界框。仅支持 PyTorch。

post_process_semantic_segmentation

< source >

( outputs target_sizes: List = None ) → export const metadata = 'undefined';List[torch.Tensor]

参数

• outputs (DetrForSegmentation) — 模型的原始输出。
• target_sizes（List[Tuple[int, int]]，可选） - 一个元组列表（Tuple[int, int]），包含批处理中每个图像的目标大小（高度，宽度）。如果未设置，预测将不会被调整大小。

返回

List[torch.Tensor]

一个长度为batch_size的列表，其中每个项目都是一个形状为（高度，宽度）的语义分割地图，对应于target_sizes条目（如果指定了target_sizes）。每个torch.Tensor的条目对应于一个语义类别 id。

将 DetrForSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

post_process_instance_segmentation

<来源>

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False ) → export const metadata = 'undefined';List[Dict]

参数

• outputs（DetrForSegmentation） - 模型的原始输出。
• threshold（float，可选，默认为 0.5） - 保留预测实例掩码的概率分数阈值。
• mask_threshold（float，可选，默认为 0.5） - 在将预测的掩码转换为二进制值时使用的阈值。
• overlap_mask_area_threshold（float，可选，默认为 0.8） - 合并或丢弃每个二进制实例掩码中的小断开部分的重叠掩码区域阈值。
• target_sizes（List[Tuple]，可选） - 长度为（batch_size）的列表，其中每个列表项（Tuple[int, int]）对应于每个预测的请求最终大小（高度，宽度）。如果未设置，预测将不会被调整大小。
• return_coco_annotation（bool，可选） - 默认为False。如果设置为True，则以 COCO 运行长度编码（RLE）格式返回分割地图。

返回

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation - 一个形状为（高度，宽度）的张量，其中每个像素表示segment_id或分割地图的List[List]运行长度编码（RLE），如果return_coco_annotation设置为True。如果未找到高于threshold的掩码，则设置为None。
• segments_info - 包含每个段的附加信息的字典。
  • id - 表示segment_id的整数。
  • label_id - 表示与segment_id对应的标签/语义类别 id 的整数。
  • score - 具有segment_id的段的预测分数。

将 DetrForSegmentation 的输出转换为实例分割预测。仅支持 PyTorch。

post_process_panoptic_segmentation

<来源>

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs（DetrForSegmentation） - 来自 DetrForSegmentation 的输出。
• threshold（float，可选，默认为 0.5） - 保留预测实例掩码的概率分数阈值。
• mask_threshold（float，可选，默认为 0.5） - 在将预测的掩码转换为二进制值时使用的阈值。
• overlap_mask_area_threshold（float，可选，默认为 0.8） - 合并或丢弃每个二进制实例掩码中的小断开部分的重叠掩码区域阈值。
• label_ids_to_fuse（Set[int]，可选） - 此状态中的标签将使其所有实例被融合在一起。例如，我们可以说图像中只能有一个天空，但可以有几个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不在其中。
• target_sizes (List[Tuple], optional) — 长度为(batch_size)的列表，每个列表项(Tuple[int, int]])对应于批处理中每个预测的请求最终大小(高度，宽度)。如果未设置，预测将不会被调整大小。

返回值

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键:

• segmentation — 形状为(height, width)的张量，每个像素代表一个segment_id，如果找不到遮罩，则为None。如果指定了target_sizes，则将分割调整为相应的target_sizes条目。
• segments_info — 包含每个段的附加信息的字典。
  • id — 代表segment_id的整数。
  • label_id — 代表与segment_id对应的标签/语义类别 id 的整数。
  • was_fused — 一个布尔值，如果label_id在label_ids_to_fuse中，则为True，否则为False。相同类别/标签的多个实例被融合并分配一个单一的segment_id。
  • score — 具有segment_id的段的预测分数。

将 DetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。

DETR 特定输出

class transformers.models.detr.modeling_detr.DetrModelOutput

< source >

( last_hidden_state: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None intermediate_hidden_states: Optional = None )

参数

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)。每层解码器的隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)。每层编码器的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组，每层一个torch.FloatTensor，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• intermediate_hidden_states（torch.FloatTensor，形状为(config.decoder_layers, batch_size, sequence_length, hidden_size)，可选，当config.auxiliary_loss=True时返回）— 中间解码器激活，即每个解码器层的输出，每个输出都经过了 layernorm。

DETR 编码器-解码器模型输出的基类。该类在 Seq2SeqModelOutput 中添加了一个属性，即一个可选的中间解码器激活堆栈，即每个解码器层的输出，每个输出都经过了 layernorm。在使用辅助解码损失训练模型时，这是有用的。

class transformers.models.detr.modeling_detr.DetrObjectDetectionOutput

<来源>

( loss: Optional = None loss_dict: Optional = None logits: FloatTensor = None pred_boxes: FloatTensor = None auxiliary_outputs: Optional = None last_hidden_state: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )

参数

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 总损失，作为类预测的负对数似然（交叉熵）和边界框损失的线性组合。后者定义为 L1 损失和广义比例不变 IoU 损失的线性组合。
• loss_dict（Dict，可选）— 包含各个损失的字典。用于记录日志。
• logits（形状为(batch_size, num_queries, num_classes + 1)的torch.FloatTensor）— 所有查询的分类 logits（包括无对象）。
• pred_boxes（形状为(batch_size, num_queries, 4)的torch.FloatTensor）— 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未归一化的边界框。
• auxiliary_outputs（list[Dict]，可选）— 仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。它是一个包含两个上述键（logits和pred_boxes）的字典列表，每个字典对应一个解码器层。
• last_hidden_state（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 模型解码器最后一层的隐藏状态序列。
• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。每个层的解码器的隐藏状态加上初始嵌入输出。
• decoder_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 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器在每一层的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

DetrForObjectDetection 的输出类型。

class transformers.models.detr.modeling_detr.DetrSegmentationOutput

<来源>

( loss: Optional = None loss_dict: Optional = None logits: FloatTensor = None pred_boxes: FloatTensor = None pred_masks: FloatTensor = None auxiliary_outputs: Optional = None last_hidden_state: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )

参数

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 作为负对数似然（交叉熵）和边界框损失的线性组合的总损失。后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
• loss_dict (Dict, optional) — 包含各个损失的字典。用于记录日志。
• logits (torch.FloatTensor of shape (batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。
• pred_boxes (torch.FloatTensor of shape (batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未归一化的边界框。
• pred_masks (torch.FloatTensor of shape (batch_size, num_queries, height/4, width/4)) — 所有查询的分割掩模 logits。另请参阅 post_process_semantic_segmentation()或 post_process_instance_segmentation()post_process_panoptic_segmentation()分别评估语义、实例和全景分割掩模。
• auxiliary_outputs (list[Dict], optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。它是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。
• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型解码器最后一层的隐藏状态序列。
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。解码器在每一层的隐藏状态加上初始嵌入输出。
• decoder_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 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。编码器在每层输出的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

DetrForSegmentation 的输出类型。

DetrModel

class transformers.DetrModel

<来源>

( config: DetrConfig )

参数

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

裸的 DETR 模型（由骨干和编码器-解码器 Transformer 组成），输出原始隐藏状态，没有特定的头部。

这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。 可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DetrImageProcessor.call()。
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免在填充像素值上执行注意力的遮罩。遮罩值选择在[0, 1]中：
  • 对于真实的像素（即未被遮罩），
  • 对于填充像素（即被遮罩）为 0。

  什么是注意力遮罩？

• decoder_attention_mask（形状为(batch_size, num_queries)的torch.FloatTensor，可选）— 默认情况下不使用。可用于屏蔽对象查询。
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递一个图像的扁平表示，而不是传递扁平特征图（骨干网络输出+投影层的输出）。
• decoder_inputs_embeds（形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递一个嵌入表示，而不是用零张量初始化查询。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.detr.modeling_detr.DetrModelOutput 或tuple(torch.FloatTensor)

一个 transformers.models.detr.modeling_detr.DetrModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（DetrConfig）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型解码器最后一层的隐藏状态序列的输出。
• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 元组包括（每个层的嵌入输出+每个层的输出的torch.FloatTensor）形状为(batch_size, sequence_length, hidden_size)。解码器在每一层的输出隐藏状态加上初始嵌入输出。
• decoder_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 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）—模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）—编码器的隐藏状态元组，形状为(batch_size, sequence_length, hidden_size)（每层一个）。每层的编码器隐藏状态加上初始嵌入输出。
• encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）—编码器的注意力权重元组，形状为(batch_size, num_heads, sequence_length, sequence_length)（每层一个）。用于计算自注意力头中的加权平均值的编码器的注意力 softmax 后的注意力权重。
• intermediate_hidden_states（形状为(config.decoder_layers, batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选，当config.auxiliary_loss=True时返回）—中间解码器激活，即每个解码器层的输出，每个都经过一个 layernorm。

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

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

示例：

>>> from transformers import AutoImageProcessor, DetrModel
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
>>> model = DetrModel.from_pretrained("facebook/detr-resnet-50")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 100, 256]

DetrForObjectDetection

class transformers.DetrForObjectDetection

<来源>

( config: DetrConfig )

参数

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

DETR 模型（由骨干和编码器-解码器 Transformer 组成），顶部带有目标检测头，用于诸如 COCO 检测之类的任务。

这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrObjectDetectionOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—像素值。默认情况下，如果提供填充，则将忽略填充。 像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 DetrImageProcessor.call()。
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）—用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 1 表示真实像素（即未屏蔽），
  • 0 表示填充像素（即屏蔽）。

  什么是注意力掩码？

• decoder_attention_mask (torch.FloatTensor of shape (batch_size, num_queries), optional) — 默认情况下不使用。可用于屏蔽对象查询。
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组由(last_hidden_state, optional: hidden_states, optional: attentions)组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递图像的扁平化特征图（骨干网络+投影层的输出），而不是传递扁平化表示。
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是用零张量初始化查询。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (List[Dict] of len (batch_size,), optional) — 用于计算二部匹配损失的标签。字典列表，每个字典至少包含以下 2 个键：‘class_labels’和’boxes’（分别是批处理中图像的类别标签和边界框）。类别标签本身应该是长度为(图像中边界框数量,)的torch.LongTensor，而边界框应该是形状为(图像中边界框数量, 4)的torch.FloatTensor。

返回

transformers.models.detr.modeling_detr.DetrObjectDetectionOutput 或 tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor of shape (1,), optional, returned when labels are provided)) — 作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合的总损失。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
• loss_dict (Dict, optional) — 包含各个损失的字典。用于记录日志。
• logits (torch.FloatTensor of shape (batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象）。
• pred_boxes (torch.FloatTensor of shape (batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未归一化的边界框。
• auxiliary_outputs (list[Dict], optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。它是一个包含每个解码器层的上述两个键（logits和pred_boxes）的字典列表。
• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型解码器最后一层的隐藏状态序列。
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 解码器的隐藏状态元组，每层一个，形状为(batch_size, sequence_length, hidden_size)。每层解码器的隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 解码器的注意力权重元组，每层一个，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 解码器的交叉注意力层的注意力权重元组，每层一个，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 编码器的隐藏状态元组，每层一个，形状为(batch_size, sequence_length, hidden_size)。每层编码器的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 编码器的注意力权重元组，每层一个，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, DetrForObjectDetection
>>> import torch
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
>>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
...     0
... ]

>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected remote with confidence 0.998 at location [40.16, 70.81, 175.55, 117.98]
Detected remote with confidence 0.996 at location [333.24, 72.55, 368.33, 187.66]
Detected couch with confidence 0.995 at location [-0.02, 1.15, 639.73, 473.76]
Detected cat with confidence 0.999 at location [13.24, 52.05, 314.02, 470.93]
Detected cat with confidence 0.999 at location [345.4, 23.85, 640.37, 368.72]

DetrForSegmentation

class transformers.DetrForSegmentation

<来源>

( config: DetrConfig )

参数

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

DETR 模型（由骨干和编码器-解码器 Transformer 组成），顶部带有分割头，用于诸如 COCO 全景等任务。

此模型继承自 PreTrainedModel。查看超类文档以获取库实现的通用方法（例如下载或保存，调整输入嵌入大小，修剪头等）。

此模型还是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrSegmentationOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。默认情况下将忽略填充。 可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DetrImageProcessor.call()。
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]中：
  • 对于真实的像素（即未被遮罩），
  • 对于填充像素（即遮罩）的像素为 0。

  什么是注意力遮罩？

• decoder_attention_mask（形状为(batch_size, num_queries)的torch.FloatTensor，可选）— 默认情况下不使用。可用于屏蔽对象查询。
• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递图像的扁平特征图（骨干+投影层的输出）而不是传递它。
• decoder_inputs_embeds（形状为(batch_size, num_queries, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示来初始化查询，而不是使用零张量。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
• labels（长度为(batch_size,)的List[Dict]，可选）— 用于计算二部匹配损失、DICE/F-1 损失和 Focal 损失的标签。字典列表，每个字典至少包含以下 3 个键：‘class_labels’、‘boxes’和‘masks’（分别是批次中图像的类标签、边界框和分割掩码）。类标签本身应该是长度为(图像中边界框的数量,)的torch.LongTensor，边界框是形状为(图像中边界框的数量, 4)的torch.FloatTensor，掩码是形状为(图像中边界框的数量, height, width)的torch.FloatTensor。

返回

transformers.models.detr.modeling_detr.DetrSegmentationOutput 或tuple(torch.FloatTensor)

一个 transformers.models.detr.modeling_detr.DetrSegmentationOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（DetrConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回） — 总损失，作为负对数似然（交叉熵）和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
• loss_dict (Dict，optional) — 包含各个损失的字典。用于记录。
• logits (torch.FloatTensor，形状为(batch_size, num_queries, num_classes + 1)） — 所有查询的分类 logits（包括无对象）。
• pred_boxes (torch.FloatTensor，形状为(batch_size, num_queries, 4)） — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批处理中每个单独图像的大小（忽略可能的填充）。您可以使用 post_process_object_detection()来检索未归一化的边界框。
• pred_masks (torch.FloatTensor，形状为(batch_size, num_queries, height/4, width/4)） — 所有查询的分割掩模 logits。另请参阅 post_process_semantic_segmentation()或 post_process_instance_segmentation()post_process_panoptic_segmentation()分别评估语义、实例和全景分割掩模。
• auxiliary_outputs (list[Dict], optional) — 当辅助损失被激活时（即config.auxiliary_loss设置为True）并且提供了标签时才返回。这是一个包含每个解码器层的两个上述键（logits和pred_boxes）的字典列表。
• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型解码器最后一层的隐藏状态序列。
• decoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。解码器在每个层的输出的隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的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 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器每一层的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

DetrForSegmentation 的前向方法重写了__call__特殊方法。

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

示例：

>>> import io
>>> import requests
>>> from PIL import Image
>>> import torch
>>> import numpy

>>> from transformers import AutoImageProcessor, DetrForSegmentation
>>> from transformers.image_transforms import rgb_to_id

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])

>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]

n_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)`，optional) — 模型解码器最后一层的隐藏状态序列。

• decoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。解码器在每个层的输出的隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的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 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。编码器每一层的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

DetrForSegmentation 的前向方法重写了__call__特殊方法。

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

示例：

>>> import io
>>> import requests
>>> from PIL import Image
>>> import torch
>>> import numpy

>>> from transformers import AutoImageProcessor, DetrForSegmentation
>>> from transformers.image_transforms import rgb_to_id

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])

>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]