Transformers 文档
DETR
并获得增强的文档体验
开始使用
该模型于2020年5月26日发布在 HF papers 上，并于2021年6月9日贡献给 Hugging Face Transformers。
DETR
DETR 由一个卷积骨干网络（backbone）和一个编码器-解码器 Transformer 组成，可以端到端地训练用于目标检测。它极大地简化了 Faster-R-CNN 和 Mask-R-CNN 等模型的复杂性，这些模型使用了诸如区域建议（region proposals）、非极大值抑制（non-maximum suppression）程序和锚框生成（anchor generation）等机制。此外，DETR 还可以通过在解码器输出之上简单地添加一个掩码头（mask head），自然地扩展以执行全景分割。
你可以在 AI at Meta 组织下找到所有原始的 DETR 检查点。
此模型由 nielsr 贡献。
点击右侧边栏中的 DETR 模型，查看更多关于如何将 DETR 应用于不同目标检测和分割任务的示例。
下面的示例演示了如何使用 Pipeline 或 AutoModel 类执行目标检测。
from transformers import pipeline
pipeline = pipeline(
"object-detection",
model="facebook/detr-resnet-50",
device_map=0
)
pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")DETR 的工作原理
以下是关于 DetrForObjectDetection 工作原理的简要说明（TLDR）：
首先，图像被发送到一个预训练的卷积骨干网络（论文中，作者使用了 ResNet-50/ResNet-101）。假设我们还添加了一个批次维度。这意味着骨干网络的输入是一个形状为 (batch_size, 3, height, width) 的张量（假设图像有 3 个颜色通道 RGB）。CNN 骨干网络输出一个新的低分辨率特征图，通常形状为 (batch_size, 2048, height/32, width/32)。然后使用 nn.Conv2D 层将其投影以匹配 DETR Transformer 的隐藏维度（默认为 256）。所以现在，我们得到了一个形状为 (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（你可以将其视为图像特征）。随后，所谓的**对象查询（object queries）**通过解码器。这是一个形状为 (batch_size, num_queries, d_model) 的张量，num_queries 通常设置为 100，并用零初始化。这些输入嵌入是学习到的位置编码，作者称之为对象查询，与编码器类似，它们被添加到每个注意力层的输入中。每个对象查询将在图像中寻找一个特定的对象。解码器通过多个自注意力层和编码器-解码器注意力层更新这些嵌入，输出相同形状的 decoder_hidden_states：(batch_size, num_queries, d_model)。接下来，顶部添加两个头用于目标检测：一个线性层用于将每个对象查询分类为其中一个对象或“无对象”，以及一个 MLP 用于预测每个查询的边界框。
该模型使用**二分匹配损失（bipartite matching loss）**进行训练：我们实际做的是将 N = 100 个对象查询中每一个的预测类别 + 边界框与地面实况（ground truth）标注进行比较，填充到相同的长度 N（因此如果一张图像仅包含 4 个对象，96 个标注将仅包含“无对象”类别和“无边界框”作为边界框）。匈牙利匹配算法（Hungarian matching algorithm）用于寻找 N 个查询与 N 个标注之间最优的一对一映射。接下来，使用标准交叉熵（用于类别）以及 L1 和 广义 IoU 损失（generalized IoU loss）的线性组合（用于边界框）来优化模型参数。
DETR 可以自然地扩展以执行全景分割（统一了语义分割和实例分割）。DetrForSegmentation 在 DetrForObjectDetection 顶部添加了一个分割掩码头。掩码头既可以联合训练，也可以分两步进行：首先训练一个 DetrForObjectDetection 模型，用于检测“事物”（实例）和“背景”（如树木、道路、天空等背景事物）周围的边界框，然后冻结所有权重，仅训练掩码头 25 个 epoch。实验表明，这两种方法的结果相似。注意，训练必须预测框，因为匈牙利匹配是使用框之间的距离计算的。
注意事项
- 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 库中可用的任何卷积骨干网络进行初始化。例如，使用 MobileNet 骨干网络进行初始化，可以通过将 DetrConfig 的
backbone属性设置为"tf_mobilenetv3_small_075"，然后使用该配置初始化模型来完成。 - 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", device_map="auto")- 选项 2：使用 Transformer 的随机初始化权重，但使用骨干网络的预训练权重实例化 DETR
from transformers import DetrConfig, DetrForObjectDetection
config = DetrConfig()
model = DetrForObjectDetection(config)- 选项 3：使用骨干网络 + Transformer 的随机初始化权重实例化 DETR
config = DetrConfig() model = DetrForObjectDetection(config)
总结一下，请参考下表
| 任务 | 目标检测 | 实例分割 | 全景分割 |
|---|---|---|---|
| 描述 | 预测图像中对象周围的边界框和类别标签 | 预测图像中对象（即实例）周围的掩码 | 预测图像中对象（即实例）以及“背景”（即树木和道路等背景事物）周围的掩码 |
| 模型 | DetrForObjectDetection | DetrForSegmentation | DetrForSegmentation |
| 示例数据集 | COCO 检测 | COCO 检测，COCO 全景 | COCO 全景 |
| 提供给 DetrImageProcessor 的标注格式 | {‘image_id’: int, ‘annotations’: list[Dict]} 每个 Dict 都是一个 COCO 对象标注 | {‘image_id’: int, ‘annotations’: list[Dict]}（如果是 COCO 检测）或 {‘file_name’: str, ‘image_id’: int, ‘segments_info’: list[Dict]}（如果是 COCO 全景） | {‘file_name’: str, ‘image_id’: int, ‘segments_info’: list[Dict]} 和 masks_path（包含掩码 PNG 文件的目录路径） |
| 后处理（即，将模型输出转换为 Pascal VOC 格式） | ~transformers.DetrImageProcessor.post_process | ~transformers.DetrImageProcessor.post_process_segmentation | ~transformers.DetrImageProcessor.post_process_segmentation, ~transformers.DetrImageProcessor.post_process_panoptic |
| 评估器（evaluators） | CocoEvaluator，使用 iou_types="bbox" | CocoEvaluator，使用 iou_types="bbox" 或 "segm" | CocoEvaluator，使用 iou_types="bbox" 或 "segm"，以及 PanopticEvaluator |
- 简而言之，应该以 COCO 检测或 COCO 全景格式准备数据，然后使用 DetrImageProcessor 创建
pixel_values、pixel_mask和可选的labels，然后可以将其用于训练（或微调）模型。 - 对于评估，应首先使用 DetrImageProcessor 的后处理方法之一转换模型的输出。这些输出可以提供给
CocoEvaluator或PanopticEvaluator，它们允许你计算平均平均精度（mAP）和全景质量（PQ）等指标。后两个对象是在 原始存储库中实现的。有关评估的更多信息，请参见 示例笔记本。
资源
- 参考这些 笔记本，了解在自定义数据集上微调 DetrForObjectDetection 和 DetrForSegmentation 的示例。
DetrConfig
class transformers.DetrConfig
< source >( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None is_encoder_decoder: bool = True backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None num_channels: int = 3 num_queries: int = 100 encoder_layers: int = 6 encoder_ffn_dim: int = 2048 encoder_attention_heads: int = 8 decoder_layers: int = 6 decoder_ffn_dim: int = 2048 decoder_attention_heads: int = 8 encoder_layerdrop: float | int = 0.0 decoder_layerdrop: float | int = 0.0 activation_function: str = 'relu' d_model: int = 256 dropout: float | int = 0.1 attention_dropout: float | int = 0.0 activation_dropout: float | int = 0.0 init_std: float = 0.02 init_xavier_std: float = 1.0 auxiliary_loss: bool = False position_embedding_type: str = 'sine' dilation: bool = False class_cost: int = 1 bbox_cost: int = 5 giou_cost: int = 2 mask_loss_coefficient: int = 1 dice_loss_coefficient: int = 1 bbox_loss_coefficient: int = 5 giou_loss_coefficient: int = 2 eos_coefficient: float = 0.1 )
参数
- is_encoder_decoder (
bool, optional, defaults toTrue) — 模型是否用作编码器/解码器。 - backbone_config (
Union[dict, ~configuration_utils.PreTrainedConfig], optional) — 骨干模型的配置。 - num_channels (
int, optional, defaults to3) — 输入通道的数量。 - num_queries (
int, optional, defaults to 100) — 对象查询的数量，即检测槽位。这是 ConditionalDetrModel 在单张图像中可以检测到的最大对象数量。对于 COCO，我们建议使用 100 个查询。 - encoder_layers (
int, optional, defaults to6) — Transformer 编码器中的隐藏层数量。如果未设置，将使用与num_layers相同的值。 - encoder_ffn_dim (
int, optional, defaults to2048) — 编码器中“中间”（通常称为前馈）层的维度。 - encoder_attention_heads (
int, optional, defaults to8) — Transformer 编码器中每个注意力层的注意力头数量。 - decoder_layers (
int, optional, defaults to6) — Transformer 解码器中的隐藏层数量。如果未设置，将使用与num_layers相同的值。 - decoder_ffn_dim (
int, optional, defaults to2048) — 解码器中“中间”（通常称为前馈）层的维度。 - decoder_attention_heads (
int, optional, defaults to8) — Transformer 解码器中每个注意力层的注意力头数量。 - encoder_layerdrop (
Union[float, int], optional, defaults to0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
Union[float, int], optional, defaults to0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](https://huggingface.co/papers/1909.11556)。 - activation_function (
str, optional, defaults torelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - d_model (
int, optional, defaults to256) — 编码器层和池化层的维度。 - dropout (
Union[float, int], optional, defaults to0.1) — 所有 dropout 层的比例。 - attention_dropout (
Union[float, int], optional, defaults to0.0) — 注意力概率的 dropout 比例。 - activation_dropout (
Union[float, int], optional, defaults to0.0) — 全连接层内激活的 dropout 比例。 - init_std (
float, optional, defaults to0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - init_xavier_std (
float, optional, defaults to1.0) — 用于交叉注意力权重的 Xavier 初始化的缩放因子。 - auxiliary_loss (
bool, optional, defaults toFalse) — 是否使用辅助解码损失（每个解码器层的损失）。 - position_embedding_type (
str, optional, defaults to"sine") — 在图像特征之上使用的位置嵌入类型。"sine"或"learned"之一。 - dilation (
bool, optional, defaults toFalse) — 是否在最后一个卷积块（DC5）中用扩张（dilation）替换步长（stride）。仅在use_timm_backbone=True时支持。 - class_cost (
int, optional, defaults to1) — 匈牙利匹配成本中分类错误的相对权重。 - bbox_cost (
int, optional, defaults to5) — 匈牙利匹配成本中 L1 边界框错误的相对权重。 - giou_cost (
int, optional, defaults to2) — 匈牙利匹配成本中广义 IoU 损失的相对权重。 - mask_loss_coefficient (
int, optional, defaults to1) — 全景分割损失中焦点损失（focal loss）的相对权重。 - dice_loss_coefficient (
int, optional, defaults to1) — 全景分割损失中 Dice 损失的相对权重。 - bbox_loss_coefficient (
int, optional, defaults to5) — 全景分割损失中 L1 边界框损失的相对权重。 - giou_loss_coefficient (
int, optional, defaults to2) — 全景分割损失中广义 IoU 损失的相对权重。 - eos_coefficient (
float, optional, defaults to0.1) — 目标检测损失中“无对象”类别的相对分类权重。
这是用于存储 DetrModel 配置的配置类。它根据指定的参数实例化 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.configDetrImageProcessor
class transformers.DetrImageProcessor
< source >( **kwargs: typing_extensions.Unpack[transformers.models.detr.image_processing_detr.DetrImageProcessorKwargs] )
参数
- format (
str, kwargs, optional, defaults toAnnotationFormat.COCO_DETECTION) — 标注的数据格式。“coco_detection” 或 “coco_panoptic” 之一。 - do_convert_annotations (
bool, kwargs, optional, defaults toTrue) — 控制是否将标注转换为 DETR 模型预期的格式。将边界框转换为(center_x, center_y, width, height)格式，并在[0, 1]范围内。可以被preprocess方法中的do_convert_annotations参数覆盖。 - **kwargs (ImagesKwargs, optional) — 其他图像预处理选项。上面列出了特定于模型的 kwargs；请参阅 TypedDict 类以获取支持的参数的完整列表。
构建一个 DetrImageProcessor 图像处理器。
preprocess
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None return_segmentation_masks: bool | None = None masks_path: str | pathlib.Path | None = None **kwargs: typing_extensions.Unpack[transformers.models.detr.image_processing_detr.DetrImageProcessorKwargs] ) → ~image_processing_base.BatchFeature
参数
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — 要预处理的图像。需要单个或一批像素值范围在 0 到 255 之间的图像。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。 - annotations (
AnnotationTypeorlist[AnnotationType], optional) — 根据应用于图像的填充进行转换的标注。 - return_segmentation_masks (
bool, optional, defaults toself.return_segmentation_masks) — 是否返回分割掩码。 - masks_path (
strorpathlib.Path, optional) — 包含分割掩码的目录路径。 - format (
str, kwargs, optional, defaults toAnnotationFormat.COCO_DETECTION) — 标注的数据格式。“coco_detection” 或 “coco_panoptic” 之一。 - do_convert_annotations (
bool, kwargs, optional, defaults toTrue) — 控制是否将标注转换为 DETR 模型预期的格式。将边界框转换为(center_x, center_y, width, height)格式，并在[0, 1]范围内。可以被preprocess方法中的do_convert_annotations参数覆盖。 - return_tensors (
stror TensorType, optional) — 如果设置为'pt'，则返回堆叠的张量，否则返回张量列表。 - **kwargs (ImagesKwargs, optional) — 其他图像预处理选项。上面列出了特定于模型的 kwargs；请参阅 TypedDict 类以获取支持的参数的完整列表。
返回
~image_processing_base.BatchFeature
- data (
dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。 - tensor_type (
Union[None, str, TensorType], optional) — 您可以在此处提供 tensor_type 以在初始化时将整数列表转换为 PyTorch/Numpy 张量。
post_process_object_detection
< 源码 >( outputs threshold: float = 0.5 target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None ) → list[Dict]
将 DetrForObjectDetection 的原始输出转换为最终的边界框，格式为 (左上角x, 左上角y, 右下角x, 右下角y)。仅支持 PyTorch。
post_process_semantic_segmentation
< 源码 >( outputs target_sizes: list[tuple[int, int]] | None = None ) → list[torch.Tensor]
参数
- outputs (DetrForSegmentation) — 模型的原始输出。
- target_sizes (
list[tuple[int, int]], 可选) — 包含批次中每张图像目标尺寸(高度, 宽度)的元组列表。如果未设置，预测结果将不会被调整大小。
返回
list[torch.Tensor]
一个长度为 batch_size 的列表，其中每个元素都是一个形状为 (height, width) 的语义分割图，对应于 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: list[tuple[int, int]] | None = None return_coco_annotation: bool | None = False ) → 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，如果return_coco_annotation设置为True，则为分割图的list[List]行程编码 (RLE)。如果未找到超过threshold的掩码，则设置为None。 - segments_info — 包含每个段的附加信息的字典。
- id — 表示
segment_id的整数。 - label_id — 表示与
segment_id对应的标签/语义类 ID 的整数。 - score — 具有
segment_id的段的预测分数。
- 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: set[int] | None = None target_sizes: list[tuple[int, int]] | None = None ) → 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 — 一个形状为
(高度, 宽度)的张量，其中每个像素代表一个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的段的预测分数。
- id — 表示
将 DetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。
DetrImageProcessorPil
class transformers.DetrImageProcessorPil
< 源码 >( **kwargs: typing_extensions.Unpack[transformers.models.detr.image_processing_pil_detr.DetrImageProcessorKwargs] )
参数
- format (
str, kwargs, 可选, 默认为AnnotationFormat.COCO_DETECTION) — 注释的数据格式。为 “coco_detection” 或 “coco_panoptic” 之一。 - do_convert_annotations (
bool, kwargs, 可选, 默认为True) — 控制是否将注释转换为 DETR 模型预期的格式。将边界框转换为(中心x, 中心y, 宽度, 高度)格式，且数值范围在[0, 1]之间。可以通过preprocess方法中的do_convert_annotations参数进行覆盖。 - ***kwargs** (ImagesKwargs, 可选) — 其他图像预处理选项。上述列出了特定于模型的关键字参数（kwargs）；有关支持参数的完整列表，请参阅 TypedDict 类。
构建一个 DetrImageProcessor 图像处理器。
preprocess
< 源码 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None return_segmentation_masks: bool | None = None masks_path: str | pathlib.Path | None = None **kwargs: typing_extensions.Unpack[transformers.models.detr.image_processing_pil_detr.DetrImageProcessorKwargs] ) → ~image_processing_base.BatchFeature
参数
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — 要预处理的图像。期望输入单张或一批像素值在 0 到 255 之间的图像。如果传入的图像像素值在 0 到 1 之间，请设置do_rescale=False。 - annotations (
AnnotationType或list[AnnotationType], 可选) — 根据应用于图像的填充（padding）进行转换的注释。 - return_segmentation_masks (
bool, 可选, 默认为self.return_segmentation_masks) — 是否返回分割掩码。 - masks_path (
str或pathlib.Path, 可选) — 包含分割掩码的目录路径。 - format (
str, kwargs, 可选, 默认为AnnotationFormat.COCO_DETECTION) — 注释的数据格式。为 “coco_detection” 或 “coco_panoptic” 之一。 - do_convert_annotations (
bool, kwargs, 可选, 默认为True) — 控制是否将注释转换为 DETR 模型预期的格式。将边界框转换为(中心x, 中心y, 宽度, 高度)格式，且数值范围在[0, 1]之间。可以通过preprocess方法中的do_convert_annotations参数进行覆盖。 - return_tensors (
str或 TensorType, 可选) — 如果设置为'pt'，则返回堆叠的张量，否则返回张量列表。 - ***kwargs** (ImagesKwargs, 可选) — 其他图像预处理选项。上述列出了特定于模型的关键字参数（kwargs）；有关支持参数的完整列表，请参阅 TypedDict 类。
返回
~image_processing_base.BatchFeature
- data (
dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。 - tensor_type (
Union[None, str, TensorType], optional) — 您可以在此处提供 tensor_type 以在初始化时将整数列表转换为 PyTorch/Numpy 张量。
post_process_object_detection
< 源码 >( outputs threshold: float = 0.5 target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None ) → list[Dict]
将 DetrForObjectDetection 的原始输出转换为最终的边界框，格式为 (左上角x, 左上角y, 右下角x, 右下角y)。仅支持 PyTorch。
post_process_semantic_segmentation
< 源码 >( outputs target_sizes: list[tuple[int, int]] | None = None ) → list[torch.Tensor]
参数
- outputs (DetrForSegmentation) — 模型的原始输出。
- target_sizes (
list[tuple[int, int]], 可选) — 包含批次中每张图像目标尺寸(高度, 宽度)的元组列表。如果未设置，预测结果将不会被调整大小。
返回
list[torch.Tensor]
一个长度为 batch_size 的列表，其中每个元素都是一个形状为 (height, width) 的语义分割图，对应于 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: list[tuple[int, int]] | None = None return_coco_annotation: bool | None = False ) → 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，如果return_coco_annotation设置为True，则为分割图的list[List]行程编码 (RLE)。如果未找到超过threshold的掩码，则设置为None。 - segments_info — 包含每个段的附加信息的字典。
- id — 表示
segment_id的整数。 - label_id — 表示与
segment_id对应的标签/语义类 ID 的整数。 - score — 具有
segment_id的段的预测分数。
- 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: set[int] | None = None target_sizes: list[tuple[int, int]] | None = None ) → 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 将包含在该集合中，而“人”的则不会。 - target_sizes (
list[Tuple], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (tuple[int, int]]) 对应批次中每个预测的最终期望尺寸（高度，宽度）。如果未设置，预测将不会被调整大小。
返回
list[Dict]
字典列表，每个图像一个，每个字典包含两个键
- segmentation — 一个形状为
(高度, 宽度)的张量，其中每个像素代表一个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的段的预测分数。
- id — 表示
将 DetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。
DETR 特有的输出
class transformers.models.detr.modeling_detr.DetrModelOutput
< 源码 >( last_hidden_state: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None decoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None decoder_attentions: tuple[torch.FloatTensor, ...] | None = None cross_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_last_hidden_state: torch.FloatTensor | None = None encoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None encoder_attentions: tuple[torch.FloatTensor, ...] | None = None intermediate_hidden_states: torch.FloatTensor | None = None )
参数
- last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的输出的隐藏状态序列。 - past_key_values (
EncoderDecoderCache, 可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速序列解码。 - 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时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(torch.FloatTensor), 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 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时返回) —torch.FloatTensor元组（一个用于嵌入输出，如果模型有嵌入层，+ 每个层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，以及可选的初始嵌入输出。
- encoder_attentions (
tuple(torch.FloatTensor), 可选，在传入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）。 - 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: torch.FloatTensor | None = None loss_dict: dict | None = None logits: torch.FloatTensor | None = None pred_boxes: torch.FloatTensor | None = None auxiliary_outputs: list[dict] | None = None last_hidden_state: torch.FloatTensor | None = None decoder_hidden_states: tuple[torch.FloatTensor] | None = None decoder_attentions: tuple[torch.FloatTensor] | None = None cross_attentions: tuple[torch.FloatTensor] | None = None encoder_last_hidden_state: torch.FloatTensor | None = None encoder_hidden_states: tuple[torch.FloatTensor] | None = None encoder_attentions: tuple[torch.FloatTensor] | None = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供了labels时返回) — 总损失，作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合。后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 - loss_dict (
Dict, 可选) — 包含各个损失项的字典。有助于记录日志。 - logits (
torch.FloatTensor，形状为(batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象类别）。 - pred_boxes (
torch.FloatTensor，形状为(batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [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时返回) —torch.FloatTensor元组（一个用于嵌入输出，如果模型有嵌入层，+ 每个层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 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时返回) —torch.FloatTensor元组（一个用于嵌入输出，如果模型有嵌入层，+ 每个层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供了labels时返回) — 总损失，作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合。后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 - loss_dict (
Dict, 可选) — 包含各个损失项的字典。有助于记录日志。 - logits (
torch.FloatTensor，形状为(batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象类别）。 - pred_boxes (
torch.FloatTensor，形状为(batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [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时返回) —torch.FloatTensor元组（一个用于嵌入输出，如果模型有嵌入层，+ 每个层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选，默认为None) — 模型编码器最后一层的输出的隐藏状态序列。 - 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, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
DetrForObjectDetection 的输出类型。
class transformers.models.detr.modeling_detr.DetrSegmentationOutput
< 源码 >( loss: torch.FloatTensor | None = None loss_dict: dict | None = None logits: torch.FloatTensor | None = None pred_boxes: torch.FloatTensor | None = None pred_masks: torch.FloatTensor | None = None auxiliary_outputs: list[dict] | None = None last_hidden_state: torch.FloatTensor | None = None decoder_hidden_states: tuple[torch.FloatTensor] | None = None decoder_attentions: tuple[torch.FloatTensor] | None = None cross_attentions: tuple[torch.FloatTensor] | None = None encoder_last_hidden_state: torch.FloatTensor | None = None encoder_hidden_states: tuple[torch.FloatTensor] | None = None encoder_attentions: tuple[torch.FloatTensor] | None = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供了labels时返回) — 总损失，作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合。后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 - loss_dict (
Dict, 可选) — 包含各个损失项的字典。有助于记录日志。 - logits (
torch.FloatTensor，形状为(batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象类别）。 - pred_boxes (
torch.FloatTensor，形状为(batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [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], 可选) — 可选，仅在启用了辅助损失（即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时返回) —torch.FloatTensor元组（一个用于嵌入输出，如果模型有嵌入层，+ 每个层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 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时返回) —torch.FloatTensor元组（一个用于嵌入输出，如果模型有嵌入层，+ 每个层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供了labels时返回) — 总损失，作为类别预测的负对数似然（交叉熵）和边界框损失的线性组合。后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 - loss_dict (
Dict, 可选) — 包含各个损失项的字典。有助于记录日志。 - logits (
torch.FloatTensor，形状为(batch_size, num_queries, num_classes + 1)) — 所有查询的分类 logits（包括无对象类别）。 - pred_boxes (
torch.FloatTensor，形状为(batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [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], 可选) — 可选，仅在启用了辅助损失（即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时返回) —torch.FloatTensor元组（一个用于嵌入输出，如果模型有嵌入层，+ 每个层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor], 可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选，默认为None) — 模型编码器最后一层的输出的隐藏状态序列。 - 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, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
DetrForSegmentation 的输出类型。
DetrModel
class transformers.DetrModel
< 源码 >( config: DetrConfig )
参数
- config (DetrConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
基础 DETR 模型（由主干网络和编码器-解码器 Transformer 组成），输出原始隐藏状态，顶部没有任何特定的检测头。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: torch.FloatTensor | None = None pixel_mask: torch.LongTensor | None = None decoder_attention_mask: torch.FloatTensor | None = None encoder_outputs: torch.FloatTensor | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → DetrModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)的torch.FloatTensor，可选) — 对应于输入图像的张量。像素值可以使用image_processor_class获取。有关详情，请参见image_processor_class.__call__（processor_class使用image_processor_class来处理图像）。 - pixel_mask (形状为
(batch_size, height, width)的torch.LongTensor，可选) — 用于避免对填充像素值进行注意力计算的掩码。掩码值选自[0, 1]：- 1 表示真实像素（即未遮蔽），
- 0 表示填充像素（即已遮蔽）。
- decoder_attention_mask (形状为
(batch_size, num_queries)的torch.FloatTensor，可选) — 用于避免在解码器中对某些对象查询进行注意力计算的掩码。掩码值选自[0, 1]：- 1 表示查询未遮蔽，
- 0 表示查询已遮蔽。
- encoder_outputs (
torch.FloatTensor，可选) — 元组包含（last_hidden_state，可选：hidden_states，可选：attentions）。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列，用于解码器的交叉注意力机制。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) — 可选地，你可以选择直接传递图像的扁平化表示，而不是传递扁平化的特征图（主干网络 + 投影层的输出）。这对于绕过视觉主干网络非常有用。 - decoder_inputs_embeds (形状为
(batch_size, num_queries, hidden_size)的torch.FloatTensor，可选) — 可选地，你可以选择直接传递嵌入表示，而不是用零张量初始化查询。这对于需要自定义查询初始化的任务非常有用。
返回
DetrModelOutput 或 tuple(torch.FloatTensor)
一个 DetrModelOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（None）和输入包含各种元素。
DetrModel 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。past_key_values (
EncoderDecoderCache，可选，在传递了use_cache=True或当config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 KV 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。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, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层的注意力权重，在注意力 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时返回) —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.FloatTensorof shape(config.decoder_layers, batch_size, sequence_length, hidden_size), optional, returned whenconfig.auxiliary_loss=True) — Intermediate decoder activations, i.e. the output of each decoder layer, each of them gone through a layernorm.
示例
>>> from transformers import AutoImageProcessor, DetrModel
>>> from PIL import Image
>>> import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("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 Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: FloatTensor pixel_mask: torch.LongTensor | None = None decoder_attention_mask: torch.FloatTensor | None = None encoder_outputs: torch.FloatTensor | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None labels: list[dict] | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → DetrObjectDetectionOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)的torch.FloatTensor) — 对应于输入图像的张量。像素值可以使用image_processor_class获取。有关详情，请参见image_processor_class.__call__（processor_class使用image_processor_class来处理图像）。 - pixel_mask (形状为
(batch_size, height, width)的torch.LongTensor，可选) — 用于避免对填充像素值进行注意力计算的掩码。掩码值选自[0, 1]：- 1 表示真实像素（即未遮蔽），
- 0 表示填充像素（即已遮蔽）。
- decoder_attention_mask (形状为
(batch_size, num_queries)的torch.FloatTensor，可选) — 用于避免在解码器中对某些对象查询进行注意力计算的掩码。掩码值选自[0, 1]：- 1 表示查询未遮蔽，
- 0 表示查询已遮蔽。
- encoder_outputs (
torch.FloatTensor，可选) — 元组包含（last_hidden_state，可选：hidden_states，可选：attentions）。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列，用于解码器的交叉注意力机制。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) — 可选地，你可以选择直接传递图像的扁平化表示，而不是传递扁平化的特征图（主干网络 + 投影层的输出）。这对于绕过视觉主干网络非常有用。 - decoder_inputs_embeds (形状为
(batch_size, num_queries, hidden_size)的torch.FloatTensor，可选) — 可选地，你可以选择直接传递嵌入表示，而不是用零张量初始化查询。这对于需要自定义查询初始化的任务非常有用。 - labels (长度为
(batch_size,)的list[Dict]，可选) — 用于计算二分匹配损失的标签。字典列表，每个字典至少包含以下 2 个键：‘class_labels’ 和 ‘boxes’（分别为批次中图像的类标签和边界框）。类标签本身应该是长度为(图像中边界框数量,)的torch.LongTensor，边界框应该是形状为(图像中边界框数量, 4)的torch.FloatTensor。
返回
DetrObjectDetectionOutput 或 tuple(torch.FloatTensor)
一个 DetrObjectDetectionOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（None）和输入包含各种元素。
DetrForObjectDetection 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
loss (
torch.FloatTensorof shape(1,), optional, 当提供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) — 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每个单独图像的大小（忽略可能的填充）。你可以使用 post_process_object_detection() 来检索未归一化的边界框。auxiliary_outputs (
list[Dict], optional) — 可选，仅在启用了辅助损失（即config.auxiliary_loss设置为True）且提供了标签时返回。它是一个字典列表，包含每个解码器层的上述两个键（logits和pred_boxes）。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时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
cross_attentions (
tuple[torch.FloatTensor], 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选, 默认为None) — 模型编码器最后一层输出的隐状态序列。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, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
示例
>>> from transformers import AutoImageProcessor, DetrForObjectDetection
>>> import torch
>>> from PIL import Image
>>> import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("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 Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: FloatTensor pixel_mask: torch.LongTensor | None = None decoder_attention_mask: torch.FloatTensor | None = None encoder_outputs: torch.FloatTensor | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None labels: list[dict] | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → DetrSegmentationOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)的torch.FloatTensor) — 对应于输入图像的张量。像素值可以使用image_processor_class获取。有关详情，请参见image_processor_class.__call__（processor_class使用image_processor_class来处理图像）。 - pixel_mask (形状为
(batch_size, height, width)的torch.LongTensor，可选) — 用于避免对填充像素值进行注意力计算的掩码。掩码值选自[0, 1]：- 1 表示真实像素（即未遮蔽），
- 0 表示填充像素（即已遮蔽）。
- decoder_attention_mask (形状为
(batch_size, num_queries)的torch.FloatTensor，可选) — 用于避免在解码器中对某些对象查询进行注意力计算的掩码。掩码值选自[0, 1]：- 1 表示查询未遮蔽，
- 0 表示查询已遮蔽。
- encoder_outputs (
torch.FloatTensor，可选) — 元组包含（last_hidden_state，可选：hidden_states，可选：attentions）。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列，用于解码器的交叉注意力机制。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) — 保留为了向后兼容，但不能用于分割，因为分割需要主干网络的多尺度特征，而当使用 inputs_embeds 绕过它时，这些特征不可用。 - decoder_inputs_embeds (形状为
(batch_size, num_queries, hidden_size)的torch.FloatTensor，可选) — 可选地，你可以选择直接传递嵌入表示，而不是用零张量初始化查询。这对于需要自定义查询初始化的任务非常有用。 - labels (长度为
(batch_size,)的list[Dict]，可选) — 用于计算二分匹配损失、DICE/F-1 损失和 Focal 损失的标签。字典列表，每个字典至少包含以下 3 个键：‘class_labels’、‘boxes’ 和 ‘masks’（分别为批次中图像的类标签、边界框和分割掩码）。类标签本身应该是长度为(图像中边界框数量,)的torch.LongTensor，边界框应该是形状为(图像中边界框数量, 4)的torch.FloatTensor，掩码应该是形状为(图像中边界框数量, height, width)的torch.FloatTensor。
返回
DetrSegmentationOutput 或 tuple(torch.FloatTensor)
一个 DetrSegmentationOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（None）和输入包含各种元素。
DetrForSegmentation 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
loss (
torch.FloatTensorof shape(1,), optional, 当提供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) — 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每个单独图像的大小（忽略可能的填充）。你可以使用 post_process_object_detection() 来检索未归一化的边界框。pred_masks (形状为
(batch_size, num_queries, height/4, width/4)的torch.FloatTensor) — 所有查询的分割掩码 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 (形状为
(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时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
cross_attentions (
tuple[torch.FloatTensor], 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选, 默认为None) — 模型编码器最后一层输出的隐状态序列。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, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
示例
>>> import io
>>> import httpx
>>> from io import BytesIO
>>> 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"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> 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"]
>>> panoptic_seg.shape
torch.Size([300, 500])
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]
>>> len(panoptic_segments_info)
5