# DETR

[DETR](https://huggingface.co/papers/2005.12872) 由一个卷积骨干网络和一个编码器-解码器 Transformer 组成，可以端到端地训练用于目标检测。它极大地简化了 Faster-R-CNN 和 Mask-R-CNN 等模型的许多复杂性，这些模型使用了区域提议、非极大值抑制流程和锚框生成等技术。此外，DETR 还可以通过在解码器输出之上简单地添加一个掩码头，自然地扩展到执行全景分割任务。

您可以在 [AI at Meta](https://huggingface.co/facebook/models?search=detr) 组织下找到所有原始的 DETR 检查点。

> [!TIP]
> 该模型由 [nielsr](https://huggingface.co/nielsr) 贡献。
>
> 点击右侧边栏中的 DETR 模型，以查看将 DETR 应用于不同目标检测和分割任务的更多示例。
>
> 在 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 中设置 `use_kernels=True`，即可用 Hub 上的优化内核替换受支持的层。有关详细信息，请参阅 [加载内核](../kernel_doc/loading_kernels)。

下面的示例演示了如何使用 [Pipeline](/docs/transformers/main/zh/main_classes/pipelines#transformers.Pipeline) 或 [AutoModel](/docs/transformers/main/zh/model_doc/auto#transformers.AutoModel) 类执行目标检测。

```python

from transformers import pipeline

pipeline = pipeline(
    "object-detection",
    model="facebook/detr-resnet-50",
    device_map=0
)

pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForObjectDetection

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 = AutoModelForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto")

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

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

results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([image.size[::-1]]), threshold=0.3)

for result in results:
    for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]):
        score, label = score.item(), label_id.item()
        box = [round(i, 2) for i in box.tolist()]
        print(f"{model.config.id2label[label]}: {score:.2f} {box}")
```

DETR 的工作原理

以下是 [DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 工作原理的简要说明：

首先，图像会经过一个预训练的卷积骨干网络（在论文中，作者使用的是 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 并初始化为零。这些输入嵌入是作者所称的 object queries 的学习型位置编码，与编码器类似，它们会被添加到每个注意力层的输入中。每个 object query 都会在图像中寻找一个特定的对象。解码器通过多个自注意力层和编码器-解码器注意力层更新这些嵌入，以输出形状相同的 `decoder_hidden_states`：`(batch_size, num_queries, d_model)`。最后，在顶部添加两个用于目标检测的头部：一个用于将每个 object query 分类为某个对象或“无对象”的线性层，以及一个用于预测每个查询的边界框的 MLP。

该模型使用**二部图匹配损失**进行训练：具体来说，我们将 N = 100 个对象查询中每一个的预测类别和边界框与真实标注进行比较，并将真实标注填充至相同的长度 N（因此，如果一张图像仅包含 4 个对象，则其余 96 个标注的类别为“无对象”，边界框为“无边界框”）。使用[匈牙利匹配算法](https://en.wikipedia.org/wiki/Hungarian_algorithm)来寻找 N 个查询与 N 个标注之间的最优一对一映射。接下来，使用标准的交叉熵损失（针对类别）以及 L1 损失和[广义 IoU 损失](https://giou.stanford.edu/)的线性组合（针对边界框）来优化模型参数。

DETR 可以自然地扩展以执行全景分割（即统一语义分割和实例分割）。[DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 在 [DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 之上添加了一个分割掩码头。该掩码头可以联合训练，也可以通过两步流程进行训练：首先训练一个 [DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 模型，以检测围绕“事物”（实例）和“物质”（如树木、道路、天空等背景事物）的边界框，然后冻结所有权重，仅训练掩码头 25 个 epoch。实验表明，这两种方法的结果相似。请注意，预测边界框是训练所必需的，因为匈牙利匹配是基于边界框之间的距离计算的。

## 备注

- DETR 使用所谓的**对象查询**来检测图像中的对象。查询的数量决定了单张图像中可检测到的最大对象数量，默认设置为 100（参见[DetrConfig](/docs/transformers/main/zh/model_doc/detr#transformers.DetrConfig)的参数`num_queries`）。请注意，保留一定的余量是有益的（在 COCO 中，作者使用了 100，而 COCO 图像中对象的最大数量约为 70）。
- DETR 的解码器并行更新查询嵌入。这与 GPT-2 等语言模型不同，后者使用的是自回归解码而非并行解码。因此，这里不使用因果注意力掩码。
- DETR 在每个自注意力和交叉注意力层中，在将隐藏状态投影为查询和键之前，会为其添加位置嵌入。对于图像的位置嵌入，可以选择固定的正弦位置嵌入或可学习的绝对位置嵌入。默认情况下，[DetrConfig](/docs/transformers/main/zh/model_doc/detr#transformers.DetrConfig) 的参数 `position_embedding_type` 被设置为 `"sine"`。
- 在训练过程中，DETR 的作者发现使用解码器中的辅助损失很有帮助，尤其是帮助模型输出每类对象的正确数量。如果将 [DetrConfig](/docs/transformers/main/zh/model_doc/detr#transformers.DetrConfig) 的参数 `auxiliary_loss` 设置为 `True`，则会在每个解码器层之后添加预测前馈神经网络和匈牙利损失（这些 FFN 共享参数）。
- 如果要在跨多个节点的分布式环境中训练模型，则应更新 *modeling_detr.py* 中 *DetrLoss* 类的 *num_boxes* 变量。在多节点上训练时，该值应设置为所有节点上目标框数量的平均值，具体可参见原始实现中的 [此处](https://github.com/facebookresearch/detr/blob/a54b77800eb8e64e3ad0d8237789fcbf2f8350c5/models/detr.py#L227-L232)。
- [DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 和 [DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 可以使用 [timm library](https://github.com/rwightman/pytorch-image-models) 中可用的任意卷积骨干网络进行初始化。例如，要使用 MobileNet 骨干网络进行初始化，只需将 [DetrConfig](/docs/transformers/main/zh/model_doc/detr#transformers.DetrConfig) 的 `backbone` 属性设置为 `"tf_mobilenetv3_small_075"`，然后使用该配置初始化模型即可。
- DETR 会对输入图像进行缩放，使得最短边至少达到一定像素数，而最长边不超过 1333 像素。在训练阶段，使用尺度增强（scale augmentation），将最短边随机设置为至少 480 像素且至多 800 像素。在推理阶段，最短边被设置为 800 像素。可以使用 [DetrImageProcessor](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor) 为模型准备图像（以及可选的 COCO 格式标注）。由于这种缩放操作，同一批次中的图像可能具有不同的尺寸。DETR 通过将图像填充（padding）至批次中的最大尺寸，并创建一个像素掩码（pixel mask）来指示哪些像素是真实像素、哪些是填充像素，从而解决了这一问题。或者，也可以自定义 `collate_fn` 来对图像进行批处理，使用 `~transformers.DetrImageProcessor.pad_and_create_pixel_mask`。
- 图像的大小将决定所使用的内存量，进而决定 `batch_size`。建议每个 GPU 使用 2 的批大小。更多信息请参见 [此 GitHub 讨论](https://github.com/facebookresearch/detr/issues/150)。

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

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

```python
from transformers import DetrForObjectDetection

model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto")
```

- 选项 2：使用随机初始化的权重实例化 Transformer 部分的 DETR，但使用预训练权重初始化 backbone

```python
from transformers import DetrConfig, DetrForObjectDetection

config = DetrConfig()
model = DetrForObjectDetection(config)
```

- 选项 3：使用随机初始化的权重实例化 DETR 的骨干网络 + Transformer

```python
config = DetrConfig()
model = DetrForObjectDetection(config)
```

作为总结，请参考下表：

| 任务 | 目标检测 | 实例分割 | 全景分割 |
|------|------------------|-----------------------|-----------------------|
| **描述** | 预测图像中物体周围的边界框和类别标签 | 预测图像中物体（即实例）周围的掩码 | 预测图像中两个对象（即实例）以及“stuff”（即树木和道路等背景物体）周围的掩码 |
| **模型** | [DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) | [DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) | [DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) |
| **示例数据集** | COCO 检测 | COCO 检测，COCO 全景 | COCO 全景                           |
| **提供给**  [DetrImageProcessor](/docs/transformers/main/zh/model_doc/detr#transformers.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` |
| **评估器** | 使用 `iou_types="bbox"` 的 `CocoEvaluator` | `CocoEvaluator` 搭配 `iou_types="bbox"` 或 `"segm"` | `CocoEvaluator` 搭配 `iou_types="bbox"` 或 `"segm"`，`PanopticEvaluator` |

- 简而言之，数据应准备为 COCO 检测或 COCO 全景分割格式，然后使用 [DetrImageProcessor](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor) 生成 `pixel_values`、`pixel_mask` 以及可选的 `labels`，随后即可用于训练（或微调）模型。
- 进行评估时，应首先使用 [DetrImageProcessor](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor) 的其中一种后处理方法将模型的输出进行转换。这些结果可以传入 `CocoEvaluator` 或 `PanopticEvaluator`，从而计算平均精度均值（mAP）和全景质量（PQ）等指标。后两者在[原始仓库](https://github.com/facebookresearch/detr)中实现。有关评估的更多信息，请参阅[示例笔记本](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR)。

## 资源

- 请参阅这些 [notebooks](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR)，其中包含在自定义数据集上微调 [DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 和 [DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的示例。

## DetrConfig[[transformers.DetrConfig]]

#### transformers.DetrConfig[[transformers.DetrConfig]]

```python
transformers.DetrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, 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)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/configuration_detr.py#L25)

**参数：**

is_encoder_decoder (`bool`，*可选*，默认为 `True`)：模型是否用作编码器/解码器。

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`，*可选*)：骨干模型的配置。

num_channels (`int`，*可选*，默认为 `3`)：输入通道数。

num_queries (`int`, *可选*，默认为 100)：对象查询的数量，即检测槽位。这是 [ConditionalDetrModel](/docs/transformers/main/zh/model_doc/conditional_detr#transformers.ConditionalDetrModel) 在单张图像中可检测到的最大对象数量。对于 COCO，我们建议使用 100 个查询。

encoder_layers (`int`，*可选*，默认为 `6`)：Transformer 编码器中的隐藏层数。如果未设置，将使用与 `num_layers` 相同的值。

encoder_ffn_dim (`int`，*可选*，默认为 `2048`)：编码器中“中间”（通常称为前馈）层的维度。

encoder_attention_heads (`int`，*可选*，默认为 `8`)：Transformer 编码器中每个注意力层的注意力头数量。

decoder_layers (`int`，*可选*，默认为 `6`)：Transformer 解码器中的隐藏层数。如果未设置，将使用与 `num_layers` 相同的值。

decoder_ffn_dim (`int`，*可选*，默认为 `2048`)：解码器中“中间”（通常称为前馈）层的维度。

decoder_attention_heads (`int`，*可选*，默认为 `8`)：Transformer 解码器中每个注意力层的注意力头数量。

encoder_layerdrop (`Union[float, int]`，*可选*，默认为 `0.0`)：编码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](see https://huggingface.co/papers/1909.11556)。

decoder_layerdrop (`Union[float, int]`，*可选*，默认值为 `0.0`)：解码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](see https://huggingface.co/papers/1909.11556)。

activation_function (`str`，*可选*，默认为 `relu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

d_model (`int`，*可选*，默认为 `256`)：编码器层和池化层的大小。

dropout (`Union[float, int]`，*可选*，默认为 `0.1`)：所有 dropout 层的比率。

attention_dropout (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。

activation_dropout (`Union[float, int]`，*可选*，默认值为 `0.0`)：全连接层内部激活值的 dropout 比率。

init_std (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

init_xavier_std (`float`, *可选*，默认为 `1.0`) : 用于交叉注意力权重 Xavier 初始化的缩放因子。

auxiliary_loss (`bool`，*可选*，默认为 `False`)：是否使用辅助解码损失（即每个解码器层的损失）。

position_embedding_type (`str`，*可选*，默认为 `"sine"`)：用于叠加在图像特征之上的位置嵌入类型。取值为 `"sine"` 或 `"learned"` 之一。

dilation (`bool`，*可选*，默认为 `False`)：是否将最后一个卷积块（DC5）中的 stride 替换为 dilation。仅在 `use_timm_backbone` = `True` 时支持。

class_cost (`int`, *可选*，默认为 `1`)：匈牙利匹配代价中分类误差的相对权重。

bbox_cost (`int`, *可选*，默认为 `5`)：匈牙利匹配代价中 L1 边界框误差的相对权重。

giou_cost (`int`, *可选*，默认为 `2`)：匈牙利匹配代价中广义 IoU 损失的相对权重。

mask_loss_coefficient (`int`, *可选*，默认为 `1`)：全景分割损失中焦点损失的相对权重。

dice_loss_coefficient (`int`, *可选*, 默认为 `1`) : 全景分割损失中 dice loss 的相对权重。

bbox_loss_coefficient (`int`, *可选*，默认为 `5`)：全景分割损失中 L1 边界框损失的相对权重。

giou_loss_coefficient (`int`, *可选*，默认为 `2`)：全景分割损失中广义 IoU 损失的相对权重。

eos_coefficient (`float`, *可选*, 默认为 `0.1`) : 目标检测损失中“无目标”类别的相对分类权重。

这是用于存储 DetrModel 配置的类。它根据指定的参数实例化 Detr 模型，并定义模型架构。使用默认值实例化配置将生成与 [facebook/detr-resnet-50](https://huggingface.co/facebook/detr-resnet-50) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> 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
```

## DetrImageProcessor[[transformers.DetrImageProcessor]]

#### transformers.DetrImageProcessor[[transformers.DetrImageProcessor]]

```python
transformers.DetrImageProcessor(**kwargs: *<class 'transformers.models.detr.image_processing_detr.DetrImageProcessorKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L426)

**参数：**

do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。

do_resize (`bool`, *kwargs*, *可选*, 默认为 `True`) : 是否调整图像大小。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `{'shortest_edge' : 800, 'longest_edge': 1333}`)：描述输入到模型的最大尺寸。

default_to_square (`bool`, *kwargs*, *可选*，默认为 `False`) : 当 size 为整数时，是否在调整大小时默认使用正方形图像。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 应用 `center_crop` 后输出图像的尺寸。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*，默认为 `2`) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。

do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`)：是否对图像进行重新缩放。

rescale_factor (`float`, *kwargs*, *可选*，默认为 `0.00392156862745098`) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。

do_normalize (`bool`，*kwargs*，*可选*，默认为 `True`)：是否对图像进行归一化。

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.485, 0.456, 0.406]`) : 用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.229, 0.224, 0.225]`) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。

do_pad (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。

do_center_crop (`bool`, *kwargs*, *可选*) : 是否对图像进行居中裁剪。

data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。

disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。

format (`str`, *kwargs*, *可选*，默认为 `AnnotationFormat.COCO_DETECTION`)：注释的数据格式。取值为 "coco_detection" 或 "coco_panoptic" 之一。

do_convert_annotations (`bool`, *kwargs*, *可选*，默认为 `True`)：控制是否将注释转换为 DETR 模型所期望的格式。将边界框转换为 `(center_x, center_y, width, height)` 格式，且范围在 `[0, 1]` 内。可通过 `preprocess` 方法中的 `do_convert_annotations` 参数进行覆盖。

构建一个 DetrImageProcessor 图像处理器。

#### preprocess[[transformers.DetrImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], 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: *<class 'transformers.models.detr.image_processing_detr.DetrImageProcessorKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L681)

**参数：**

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]`，*可选*)：根据应用于图像的填充进行转换的注释。

return_segmentation_masks (`bool`, *可选*, 默认为 `self.return_segmentation_masks`) : 是否返回分割掩码。

masks_path (`str` 或 `pathlib.Path`，*可选*)：包含分割掩码的目录路径。

do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。

do_resize (`bool`，*kwargs*，*可选*)：是否调整图像大小。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*)：描述模型的最大输入维度。

default_to_square (`bool`, *kwargs*, *可选*) : 当 size 为 int 时，是否在调整大小时默认使用正方形图像。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 应用 `center_crop` 后输出图像的尺寸。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。

do_rescale (`bool`, *kwargs*, *可选*) : 是否对图像进行重新缩放。

rescale_factor (`float`, *kwargs*, *可选*) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。

do_normalize (`bool`, *kwargs*, *可选*) : 是否对图像进行归一化。

image_mean (`Union[float, list[float], tuple[float, ...]]`，*kwargs*，*可选*)：用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。

do_pad (`bool`, *kwargs*, *可选*) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。

do_center_crop (`bool`, *kwargs*, *可选*) : 是否对图像进行居中裁剪。

data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。

disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。

format (`str`, *kwargs*, *可选*，默认为 `AnnotationFormat.COCO_DETECTION`)：注释的数据格式。取值为 "coco_detection" 或 "coco_panoptic" 之一。

do_convert_annotations (`bool`, *kwargs*, *可选*，默认为 `True`)：控制是否将注释转换为 DETR 模型所期望的格式。将边界框转换为 `(center_x, center_y, width, height)` 格式，且范围在 `[0, 1]` 内。可通过 `preprocess` 方法中的 `do_convert_annotations` 参数进行覆盖。

**返回：** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- 由 __call__ 方法返回的列表/数组/张量字典（例如 'pixel_values'）。
- **tensor_type** (`Union[None, str, TensorType]`，*可选*) -- 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。

#### post_process_object_detection[[transformers.DetrImageProcessor.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L823)

**参数：**

outputs (`DetrObjectDetectionOutput`)：模型的原始输出。

threshold (`float`, *可选*) : 用于保留目标检测预测结果的分数阈值。

target_sizes (`torch.Tensor` 或 `list[tuple[int, int]]`，*可选*)：形状为 `(batch_size, 2)` 的张量，或包含元组（`tuple[int, int]`）的列表，其中包含批处理中每张图片的目标尺寸 `(height, width)`。如果未设置，预测结果将不会被调整大小。

**返回：** `list[Dict]`

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

将 [DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 的原始输出转换为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y) 格式的边界框。仅支持 PyTorch。

#### post_process_semantic_segmentation[[transformers.DetrImageProcessor.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L876)

**参数：**

outputs ([DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation))：模型的原始输出。

target_sizes (`list[tuple[int, int]]`，*可选*)：一个元组列表（`tuple[int, int]`），包含批处理中每张图片的目标尺寸（高度、宽度）。如果未设置，预测结果将不会被调整大小。

return_segmentation_scores (`bool`，*可选*，默认为 `False`)：是否同时返回分割分数和分割图。当为 `True` 时，返回列表中的每个元素都是一个 `SemanticSegmentationPostProcessorOutput`，包含字段 `segmentation`（类别 ID，形状为 `(height, width)`）和 `segmentation_scores`（形状为 `(num_classes, height, width)`）。

**返回：** `list[torch.Tensor]` 或 `list[SemanticSegmentationPostProcessorOutput]`

当 `return_segmentation_scores=False`（默认值）时，返回一个长度为 `batch_size` 的列表，其中每个元素都是形状为 `(height, width)` 且包含类别 ID 的分割图。当 `return_segmentation_scores=True` 时，返回一个 `SemanticSegmentationPostProcessorOutput` 列表，包含字段 `segmentation`（类别 ID，形状为 `(height, width)`）和 `segmentation_scores`（形状为 `(num_classes, height, width)`）。在这两种情况下，`(height, width)` 均对应目标尺寸（如果指定了 `target_sizes`）。

将 [DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的输出转换为语义分割图。仅支持 PyTorch。

#### post_process_instance_segmentation[[transformers.DetrImageProcessor.post_process_instance_segmentation]]

```python
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)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L947)

**参数：**

outputs ([DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.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** -- A tensor of shape `(height, width)` where each pixel represents a `segment_id` or `list[List]` run-length encoding (RLE) of the segmentation map if return_coco_annotation is set to `True`. Set to `None` if no mask if found above `threshold`.
- **segments_info** -- 一个包含每个片段附加信息的字典。
  - **id** -- 一个表示 `segment_id` 的整数。
  - **label_id** -- 一个整数，表示与 `segment_id` 对应的标签/语义类别 ID。
  - **score** -- 具有 `segment_id` 的片段的预测分数。

将 [DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的输出转换为实例分割预测。仅支持 PyTorch。

#### post_process_panoptic_segmentation[[transformers.DetrImageProcessor.post_process_panoptic_segmentation]]

```python
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)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L1030)

**参数：**

outputs ([DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation))：[DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.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`，则 segmentation 会被调整大小以对应 `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](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的输出转换为图像全景分割预测。仅支持 PyTorch。

## DetrImageProcessorPil[[transformers.DetrImageProcessorPil]]

#### transformers.DetrImageProcessorPil[[transformers.DetrImageProcessorPil]]

```python
transformers.DetrImageProcessorPil(**kwargs: *<class 'transformers.models.detr.image_processing_pil_detr.DetrImageProcessorKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L432)

**参数：**

do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。

do_resize (`bool`, *kwargs*, *可选*, 默认为 `True`) : 是否调整图像大小。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `{'shortest_edge' : 800, 'longest_edge': 1333}`)：描述输入到模型的最大尺寸。

default_to_square (`bool`, *kwargs*, *可选*，默认为 `False`) : 当 size 为整数时，是否在调整大小时默认使用正方形图像。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 应用 `center_crop` 后输出图像的尺寸。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*，默认为 `2`) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。

do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`)：是否对图像进行重新缩放。

rescale_factor (`float`, *kwargs*, *可选*，默认为 `0.00392156862745098`) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。

do_normalize (`bool`，*kwargs*，*可选*，默认为 `True`)：是否对图像进行归一化。

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.485, 0.456, 0.406]`) : 用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.229, 0.224, 0.225]`) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。

do_pad (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。

do_center_crop (`bool`, *kwargs*, *可选*) : 是否对图像进行居中裁剪。

data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。

disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。

format (`str`, *kwargs*, *可选*，默认为 `AnnotationFormat.COCO_DETECTION`)：注释的数据格式。取值为 "coco_detection" 或 "coco_panoptic" 之一。

do_convert_annotations (`bool`, *kwargs*, *可选*，默认为 `True`)：控制是否将注释转换为 DETR 模型所期望的格式。将边界框转换为 `(center_x, center_y, width, height)` 格式，且范围在 `[0, 1]` 内。可通过 `preprocess` 方法中的 `do_convert_annotations` 参数进行覆盖。

构建一个 DetrImageProcessor 图像处理器。

#### preprocess[[transformers.DetrImageProcessorPil.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], 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: *<class 'transformers.models.detr.image_processing_pil_detr.DetrImageProcessorKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L700)

**参数：**

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]`，*可选*)：根据应用于图像的填充进行转换的注释。

return_segmentation_masks (`bool`, *可选*, 默认为 `self.return_segmentation_masks`) : 是否返回分割掩码。

masks_path (`str` 或 `pathlib.Path`，*可选*)：包含分割掩码的目录路径。

do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。

do_resize (`bool`，*kwargs*，*可选*)：是否调整图像大小。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*)：描述模型的最大输入维度。

default_to_square (`bool`, *kwargs*, *可选*) : 当 size 为 int 时，是否在调整大小时默认使用正方形图像。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 应用 `center_crop` 后输出图像的尺寸。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。

do_rescale (`bool`, *kwargs*, *可选*) : 是否对图像进行重新缩放。

rescale_factor (`float`, *kwargs*, *可选*) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。

do_normalize (`bool`, *kwargs*, *可选*) : 是否对图像进行归一化。

image_mean (`Union[float, list[float], tuple[float, ...]]`，*kwargs*，*可选*)：用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。

do_pad (`bool`, *kwargs*, *可选*) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。

do_center_crop (`bool`, *kwargs*, *可选*) : 是否对图像进行居中裁剪。

data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。

disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。

format (`str`, *kwargs*, *可选*，默认为 `AnnotationFormat.COCO_DETECTION`)：注释的数据格式。取值为 "coco_detection" 或 "coco_panoptic" 之一。

do_convert_annotations (`bool`, *kwargs*, *可选*，默认为 `True`)：控制是否将注释转换为 DETR 模型所期望的格式。将边界框转换为 `(center_x, center_y, width, height)` 格式，且范围在 `[0, 1]` 内。可通过 `preprocess` 方法中的 `do_convert_annotations` 参数进行覆盖。

**返回：** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- 由 __call__ 方法返回的列表/数组/张量字典（例如 'pixel_values'）。
- **tensor_type** (`Union[None, str, TensorType]`，*可选*) -- 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。

#### post_process_object_detection[[transformers.DetrImageProcessorPil.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L845)

**参数：**

outputs (`DetrObjectDetectionOutput`)：模型的原始输出。

threshold (`float`, *可选*) : 用于保留目标检测预测结果的分数阈值。

target_sizes (`torch.Tensor` 或 `list[tuple[int, int]]`，*可选*)：形状为 `(batch_size, 2)` 的张量，或包含元组（`tuple[int, int]`）的列表，其中包含批处理中每张图片的目标尺寸 `(height, width)`。如果未设置，预测结果将不会被调整大小。

**返回：** `list[Dict]`

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

将 [DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 的原始输出转换为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y) 格式的边界框。仅支持 PyTorch。

#### post_process_semantic_segmentation[[transformers.DetrImageProcessorPil.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L899)

**参数：**

outputs ([DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation))：模型的原始输出。

target_sizes (`list[tuple[int, int]]`，*可选*)：一个元组列表（`tuple[int, int]`），包含批处理中每张图片的目标尺寸（高度、宽度）。如果未设置，预测结果将不会被调整大小。

return_segmentation_scores (`bool`，*可选*，默认为 `False`)：是否同时返回分割分数和分割图。当为 `True` 时，返回列表中的每个元素都是一个 `SemanticSegmentationPostProcessorOutput`，包含字段 `segmentation`（类别 ID，形状为 `(height, width)`）和 `segmentation_scores`（形状为 `(num_classes, height, width)`）。

**返回：** `list[torch.Tensor]` 或 `list[SemanticSegmentationPostProcessorOutput]`

当 `return_segmentation_scores=False`（默认值）时，返回一个长度为 `batch_size` 的列表，其中每个元素都是形状为 `(height, width)` 且包含类别 ID 的分割图。当 `return_segmentation_scores=True` 时，返回一个 `SemanticSegmentationPostProcessorOutput` 列表，包含字段 `segmentation`（类别 ID，形状为 `(height, width)`）和 `segmentation_scores`（形状为 `(num_classes, height, width)`）。在这两种情况下，`(height, width)` 均对应目标尺寸（如果指定了 `target_sizes`）。

将 [DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的输出转换为语义分割图。仅支持 PyTorch。

#### post_process_instance_segmentation[[transformers.DetrImageProcessorPil.post_process_instance_segmentation]]

```python
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)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L971)

**参数：**

outputs ([DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.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** -- A tensor of shape `(height, width)` where each pixel represents a `segment_id` or `list[List]` run-length encoding (RLE) of the segmentation map if return_coco_annotation is set to `True`. Set to `None` if no mask if found above `threshold`.
- **segments_info** -- 一个包含每个片段附加信息的字典。
  - **id** -- 一个表示 `segment_id` 的整数。
  - **label_id** -- 一个整数，表示与 `segment_id` 对应的标签/语义类别 ID。
  - **score** -- 具有 `segment_id` 的片段的预测分数。

将 [DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的输出转换为实例分割预测。仅支持 PyTorch。

#### post_process_panoptic_segmentation[[transformers.DetrImageProcessorPil.post_process_panoptic_segmentation]]

```python
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)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L1055)

**参数：**

outputs ([DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation))：[DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.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`，则 segmentation 会被调整大小以对应 `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](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的输出转换为图像全景分割预测。仅支持 PyTorch。

## DETR 特定输出[[transformers.models.detr.modeling_detr.DetrModelOutput]]

#### transformers.models.detr.modeling_detr.DetrModelOutput[[transformers.models.detr.modeling_detr.DetrModelOutput]]

```python
transformers.models.detr.modeling_detr.DetrModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, intermediate_hidden_states: typing.Optional[torch.Tensor] = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L76)

**参数：**

last_hidden_state （形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）：模型解码器最后一层输出的隐藏状态序列。如果使用了 `past_key_values`，则仅输出形状为 `(batch_size, 1, hidden_size)` 的序列最后一个隐藏状态。

past_key_values (`EncoderDecoderCache`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回)：它是一个 [EncoderDecoderCache](/docs/transformers/main/zh/internal/generation_utils#transformers.EncoderDecoderCache) 实例。有关更多详细信息，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/kv_cache)。包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 `past_key_values` 输入）加速顺序解码。

decoder_hidden_states (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。解码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

decoder_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

cross_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。

encoder_last_hidden_state (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：模型编码器最后一层输出的隐藏状态序列。

encoder_hidden_states (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。编码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

encoder_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。编码器的注意力权重，经过注意力 softmax 后，用于在自注意力头中计算加权平均值。

intermediate_hidden_states (`torch.Tensor`，形状为 `(config.decoder_layers, batch_size, sequence_length, hidden_size)`，*可选*，当 `config.auxiliary_loss=True` 时返回)：中间解码器激活值，即每个解码器层的输出，每个输出都经过了一次层归一化。

DETR 编码器-解码器模型输出的基类。该类在 Seq2SeqModelOutput 的基础上增加了一个属性，即可选的中间解码器激活值堆栈，也就是每个解码器层的输出，且每个输出都经过了一次层归一化。这在训练模型时使用辅助解码损失时非常有用。

#### transformers.models.detr.modeling_detr.DetrObjectDetectionOutput[[transformers.models.detr.modeling_detr.DetrObjectDetectionOutput]]

```python
transformers.models.detr.modeling_detr.DetrObjectDetectionOutput(loss: typing.Optional[torch.Tensor] = None, loss_dict: dict | None = None, logits: typing.Optional[torch.Tensor] = None, pred_boxes: typing.Optional[torch.Tensor] = None, auxiliary_outputs: list[dict] | None = None, last_hidden_state: typing.Optional[torch.Tensor] = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L92)

**参数：**

loss (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回)) : 总损失，是类别预测的负对数似然（交叉熵）损失与边界框损失的线性组合。后者定义为 L1 损失与广义尺度不变 IoU 损失的线性组合。

loss_dict (`Dict`, *可选*) : 包含各项损失的字典。适用于日志记录。

logits (`torch.Tensor`，形状为 `(batch_size, num_queries, num_classes + 1)`)：所有查询的分类 logits（包括 no-object）。

pred_boxes (`torch.Tensor`，形状为 `(batch_size, num_queries, 4)`)：所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每张图片各自的尺寸（忽略可能的填充）。您可以使用 [post_process_object_detection()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection) 来获取未归一化的边界框。

auxiliary_outputs (`list[Dict]`, *可选*) : 可选，仅在启用辅助损失（即 `config.auxiliary_loss` 设置为 `True`）且提供了标签时返回。它是一个字典列表，包含每个解码器层的上述两个键（`logits` 和 `pred_boxes`）。

last_hidden_state (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：模型解码器最后一层输出的隐藏状态序列。

decoder_hidden_states (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：`torch.Tensor` 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。解码器在每层输出处的隐藏状态，以及初始嵌入输出。

decoder_attentions (`tuple[torch.Tensor]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

cross_attentions (`tuple[torch.Tensor]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。解码器交叉注意力层的注意力权重，经过注意力 softmax 后，用于在交叉注意力头中计算加权平均值。

encoder_last_hidden_state (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：模型编码器最后一层输出的隐藏状态序列。

encoder_hidden_states (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：`torch.Tensor` 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。编码器在每层输出处的隐藏状态以及初始嵌入输出。

encoder_attentions (`tuple[torch.Tensor]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。编码器的注意力权重，经过注意力 softmax 后，用于在自注意力头中计算加权平均值。

[DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 的输出类型。

#### transformers.models.detr.modeling_detr.DetrSegmentationOutput[[transformers.models.detr.modeling_detr.DetrSegmentationOutput]]

```python
transformers.models.detr.modeling_detr.DetrSegmentationOutput(loss: typing.Optional[torch.Tensor] = None, loss_dict: dict | None = None, logits: typing.Optional[torch.Tensor] = None, pred_boxes: typing.Optional[torch.Tensor] = None, pred_masks: typing.Optional[torch.Tensor] = None, auxiliary_outputs: list[dict] | None = None, last_hidden_state: typing.Optional[torch.Tensor] = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L135)

**参数：**

loss (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回)) : 总损失，是类别预测的负对数似然（交叉熵）损失与边界框损失的线性组合。后者定义为 L1 损失与广义尺度不变 IoU 损失的线性组合。

loss_dict (`Dict`, *可选*) : 包含各项损失的字典。适用于日志记录。

logits (`torch.Tensor`，形状为 `(batch_size, num_queries, num_classes + 1)`)：所有查询的分类 logits（包括 no-object）。

pred_boxes (`torch.Tensor`，形状为 `(batch_size, num_queries, 4)`)：所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每张图片各自的尺寸（忽略可能的填充）。您可以使用 [post_process_object_detection()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection) 来获取未归一化的边界框。

pred_masks (`torch.Tensor`，形状为 `(batch_size, num_queries, height/4, width/4)`)：所有查询的分割掩码 logits。请参阅 [post_process_semantic_segmentation()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation) 或 [post_process_instance_segmentation()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation) [post_process_panoptic_segmentation()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation)，分别用于评估语义、实例和全景分割掩码。

auxiliary_outputs (`list[Dict]`, *可选*) : 可选，仅在启用辅助损失（即 `config.auxiliary_loss` 设置为 `True`）且提供了标签时返回。它是一个字典列表，包含每个解码器层的上述两个键（`logits` 和 `pred_boxes`）。

last_hidden_state (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：模型解码器最后一层输出的隐藏状态序列。

decoder_hidden_states (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：`torch.Tensor` 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。解码器在每层输出处的隐藏状态，以及初始嵌入输出。

decoder_attentions (`tuple[torch.Tensor]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

cross_attentions (`tuple[torch.Tensor]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。解码器交叉注意力层的注意力权重，经过注意力 softmax 后，用于在交叉注意力头中计算加权平均值。

encoder_last_hidden_state (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：模型编码器最后一层输出的隐藏状态序列。

encoder_hidden_states (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：`torch.Tensor` 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。编码器在每层输出处的隐藏状态以及初始嵌入输出。

encoder_attentions (`tuple[torch.Tensor]`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。编码器的注意力权重，经过注意力 softmax 后，用于在自注意力头中计算加权平均值。

[DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的输出类型。

## DetrModel[[transformers.DetrModel]]

#### transformers.DetrModel[[transformers.DetrModel]]

```python
transformers.DetrModel(config: DetrConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1115)

**参数：**

config ([DetrConfig](/docs/transformers/main/zh/model_doc/detr#transformers.DetrConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

原始的 DETR 模型（由骨干网络和编码器-解码器 Transformer 组成），输出原始隐藏状态，顶部没有添加任何特定的预测头。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.DetrModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1144)

**参数：**

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 `image_processor_class` 获取像素值。有关详细信息，请参阅 `image_processor_class.__call__`（`processor_class` 使用 `image_processor_class` 处理图像）。

pixel_mask (`torch.LongTensor`，形状为 `(batch_size, height, width)`，*可选*)：用于避免对填充像素值执行注意力的掩码。掩码值取自 `[0, 1]`：  - 1 表示真实像素（即 **未掩码**）， - 0 表示填充像素（即 **已掩码**）。  [什么是注意力掩码？](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`，形状为 `(batch_size, num_queries)`，*可选*) : 用于避免在解码器中对某些对象查询执行注意力的掩码。掩码值选自 `[0, 1]`： - 对于**未掩码**的查询，值为 1； - 对于**已掩码**的查询，值为 0。

encoder_outputs (`torch.Tensor`, *可选*) : 由 (`last_hidden_state`, *可选*: `hidden_states`, *可选*: `attentions`) `last_hidden_state` 形状为 `(batch_size, sequence_length, hidden_size)`, *可选*) 组成的元组，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，除了传入展平的特征图（backbone + 投影层的输出）外，还可以选择直接传入图像的展平表示。这有助于绕过视觉 backbone。

decoder_inputs_embeds (`torch.Tensor`，形状为 `(batch_size, num_queries, hidden_size)`，*可选*)：可选地，您可以选择直接传入嵌入表示，而不是用零张量来初始化查询。这对于需要自定义查询初始化的任务非常有用。

**返回：** [DetrModelOutput](/docs/transformers/main/zh/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) 或 `tuple(torch.Tensor)`

一个 [DetrModelOutput](/docs/transformers/main/zh/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（`None`）和输入。

[DetrModel](/docs/transformers/main/zh/model_doc/detr#transformers.DetrModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型解码器最后一层输出的隐藏状态序列。

  如果使用了 `past_key_values`，则仅输出形状为 `(batch_size, 1, hidden_size)` 的序列的最后一个隐藏状态。
- **past_key_values**（`EncoderDecoderCache`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回）-- 它是一个 [EncoderDecoderCache](/docs/transformers/main/zh/internal/generation_utils#transformers.EncoderDecoderCache) 实例。更多详情，请参阅我们的 [kv cache 指南](https://huggingface.co/docs/transformers/en/kv_cache)。

  包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 `past_key_values` 输入）加速顺序解码。
- **decoder_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  解码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **decoder_attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **cross_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- **encoder_last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型编码器最后一层输出的隐藏状态序列。
- **encoder_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  编码器每层输出处的隐藏状态，以及可选的初始嵌入输出。
- **encoder_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **intermediate_hidden_states**（形状为 `(config.decoder_layers, batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*，当 `config.auxiliary_loss=True` 时返回）-- 中间解码器激活值，即每个解码器层的输出，且每个输出都经过了层归一化。

示例：

```python
>>> from transformers import AutoImageProcessor, DetrModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("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[[transformers.DetrForObjectDetection]]

#### transformers.DetrForObjectDetection[[transformers.DetrForObjectDetection]]

```python
transformers.DetrForObjectDetection(config: DetrConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1309)

**参数：**

config ([DetrConfig](/docs/transformers/main/zh/model_doc/detr#transformers.DetrConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

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

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.DetrForObjectDetection.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1327)

**参数：**

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`)：与输入图像对应的张量。可以使用 `image_processor_class` 获取像素值。有关详细信息，请参阅 `image_processor_class.__call__`（`processor_class` 使用 `image_processor_class` 处理图像）。

pixel_mask (`torch.LongTensor`，形状为 `(batch_size, height, width)`，*可选*)：用于避免对填充像素值执行注意力的掩码。掩码值取自 `[0, 1]`：  - 1 表示真实像素（即 **未掩码**）， - 0 表示填充像素（即 **已掩码**）。  [什么是注意力掩码？](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`，形状为 `(batch_size, num_queries)`，*可选*) : 用于避免在解码器中对某些对象查询执行注意力的掩码。掩码值选自 `[0, 1]`： - 对于**未掩码**的查询，值为 1； - 对于**已掩码**的查询，值为 0。

encoder_outputs (`torch.Tensor`, *可选*) : 由 (`last_hidden_state`, *可选*: `hidden_states`, *可选*: `attentions`) `last_hidden_state` 形状为 `(batch_size, sequence_length, hidden_size)`, *可选*) 组成的元组，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，除了传入展平的特征图（backbone + 投影层的输出）外，还可以选择直接传入图像的展平表示。这有助于绕过视觉 backbone。

decoder_inputs_embeds (`torch.Tensor`，形状为 `(batch_size, num_queries, hidden_size)`，*可选*)：可选地，您可以选择直接传入嵌入表示，而不是用零张量来初始化查询。这对于需要自定义查询初始化的任务非常有用。

labels (`list[Dict]`，长度为 `(batch_size,)`，*可选*) : 用于计算二分匹配损失的标签。一个字典列表，每个字典至少包含以下 2 个键：'class_labels' 和 'boxes'（分别表示批次中某张图像的分类标签和边界框）。分类标签本身应是一个长度为 `(number of bounding boxes in the image,)` 的 `torch.LongTensor`，边界框应是一个形状为 `(number of bounding boxes in the image, 4)` 的 `torch.Tensor`。

**返回：** [DetrObjectDetectionOutput](/docs/transformers/main/zh/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) 或 `tuple(torch.Tensor)`

一个 [DetrObjectDetectionOutput](/docs/transformers/main/zh/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（`None`）和输入。

[DetrForObjectDetection](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForObjectDetection) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回)) -- 总损失，是类别预测的负对数似然（交叉熵）与边界框损失的线性组合。后者定义为 L1 损失与广义尺度不变 IoU 损失的线性组合。
- **loss_dict** (`Dict`, *可选*) -- 包含各项单独损失的字典。适用于日志记录。
- **logits**（形状为 `(batch_size, num_queries, num_classes + 1)` 的 `torch.Tensor`）-- 所有查询的分类 logits（包括 no-object）。
- **pred_boxes**（形状为 `(batch_size, num_queries, 4)` 的 `torch.Tensor`）-- 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每张图片的单独尺寸（忽略可能的填充）。您可以使用 [post_process_object_detection()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection) 来获取未归一化的边界框。
- **auxiliary_outputs** (`list[Dict]`, *可选*) -- 可选，仅在启用辅助损失（即 `config.auxiliary_loss` 设置为 `True`）且提供了标签时返回。它是一个字典列表，包含每个解码器层的上述两个键（`logits` 和 `pred_boxes`）。
- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型解码器最后一层输出的隐藏状态序列。
- **decoder_hidden_states** (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- **decoder_attentions** (`tuple[torch.Tensor]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **cross_attentions** (`tuple[torch.Tensor]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- **encoder_last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型编码器最后一层输出的隐藏状态序列。
- **encoder_hidden_states** (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- **encoder_attentions**（`tuple[torch.Tensor]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回）-- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

```python
>>> from transformers import AutoImageProcessor, DetrForObjectDetection
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("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[[transformers.DetrForSegmentation]]

#### transformers.DetrForSegmentation[[transformers.DetrForSegmentation]]

```python
transformers.DetrForSegmentation(config: DetrConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1441)

**参数：**

config ([DetrConfig](/docs/transformers/main/zh/model_doc/detr#transformers.DetrConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

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

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.DetrForSegmentation.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1463)

**参数：**

pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`)：与输入图像对应的张量。可以使用 `image_processor_class` 获取像素值。有关详细信息，请参阅 `image_processor_class.__call__`（`processor_class` 使用 `image_processor_class` 处理图像）。

pixel_mask (`torch.LongTensor`，形状为 `(batch_size, height, width)`，*可选*)：用于避免对填充像素值执行注意力的掩码。掩码值取自 `[0, 1]`：  - 1 表示真实像素（即 **未掩码**）， - 0 表示填充像素（即 **已掩码**）。  [什么是注意力掩码？](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`，形状为 `(batch_size, num_queries)`，*可选*) : 用于避免在解码器中对某些对象查询执行注意力的掩码。掩码值选自 `[0, 1]`： - 对于**未掩码**的查询，值为 1； - 对于**已掩码**的查询，值为 0。

encoder_outputs (`torch.Tensor`, *可选*) : 由 (`last_hidden_state`, *可选*: `hidden_states`, *可选*: `attentions`) `last_hidden_state` 形状为 `(batch_size, sequence_length, hidden_size)`, *可选*) 组成的元组，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：为保持向后兼容性而保留，但无法用于分割，因为分割需要来自骨干网络的多尺度特征，而使用 inputs_embeds 绕过骨干网络时无法获取这些特征。

decoder_inputs_embeds (`torch.Tensor`，形状为 `(batch_size, num_queries, hidden_size)`，*可选*)：可选地，您可以选择直接传入嵌入表示，而不是用零张量来初始化查询。这对于需要自定义查询初始化的任务非常有用。

labels (`list[Dict]`，长度为 `(batch_size,)`，*可选*) : 用于计算二分匹配损失、DICE/F-1 损失和 Focal 损失的标签。一个字典列表，每个字典至少包含以下 3 个键：'class_labels'、'boxes' 和 'masks'（分别表示批次中某张图像的分类标签、边界框和分割掩码）。分类标签本身应为长度为 `(number of bounding boxes in the image,)` 的 `torch.LongTensor`，边界框应为形状为 `(number of bounding boxes in the image, 4)` 的 `torch.Tensor`，掩码应为形状为 `(number of bounding boxes in the image, height, width)` 的 `torch.Tensor`。

**返回：** [DetrSegmentationOutput](/docs/transformers/main/zh/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) 或 `tuple(torch.Tensor)`

一个 [DetrSegmentationOutput](/docs/transformers/main/zh/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（`None`）和输入。

[DetrForSegmentation](/docs/transformers/main/zh/model_doc/detr#transformers.DetrForSegmentation) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回)) -- 总损失，是类别预测的负对数似然（交叉熵）与边界框损失的线性组合。后者定义为 L1 损失与广义尺度不变 IoU 损失的线性组合。
- **loss_dict** (`Dict`, *可选*) -- 包含各项单独损失的字典。适用于日志记录。
- **logits**（形状为 `(batch_size, num_queries, num_classes + 1)` 的 `torch.Tensor`）-- 所有查询的分类 logits（包括 no-object）。
- **pred_boxes**（形状为 `(batch_size, num_queries, 4)` 的 `torch.Tensor`）-- 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每张图片的单独尺寸（忽略可能的填充）。您可以使用 [post_process_object_detection()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection) 来获取未归一化的边界框。
- **pred_masks**（形状为 `(batch_size, num_queries, height/4, width/4)` 的 `torch.Tensor`）-- 所有查询的分割掩码 logits。另请参阅 [post_process_semantic_segmentation()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation) 或 [post_process_instance_segmentation()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation) [post_process_panoptic_segmentation()](/docs/transformers/main/zh/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation)，分别用于评估语义、实例和全景分割掩码。
- **auxiliary_outputs** (`list[Dict]`, *可选*) -- 可选，仅在启用辅助损失（即 `config.auxiliary_loss` 设置为 `True`）且提供了标签时返回。它是一个字典列表，包含每个解码器层的上述两个键（`logits` 和 `pred_boxes`）。
- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型解码器最后一层输出的隐藏状态序列。
- **decoder_hidden_states** (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- **decoder_attentions** (`tuple[torch.Tensor]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **cross_attentions** (`tuple[torch.Tensor]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- **encoder_last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型编码器最后一层输出的隐藏状态序列。
- **encoder_hidden_states** (`tuple[torch.Tensor]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- **encoder_attentions**（`tuple[torch.Tensor]`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回）-- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

```python
>>> import io
>>> from huggingface_hub.utils 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
```