Hugging Face 的标志

Transformers 文档

Conditional DETR

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Conditional DETR

PyTorch

概述

Conditional DETR 模型由 Depu Meng、Xiaokang Chen、Zejia Fan、Gang Zeng、Houqiang Li、Yuhui Yuan、Lei Sun、Jingdong Wang 在 Conditional DETR for Fast Training Convergence 中提出。Conditional DETR 提出了一种条件交叉注意力机制，用于快速 DETR 训练。Conditional DETR 的收敛速度比 DETR 快 6.7 倍到 10 倍。

本文的摘要如下：

最近开发的 DETR 方法将 Transformer 编码器和解码器架构应用于目标检测，并取得了令人鼓舞的性能。在本文中，我们处理了关键问题，即训练收敛速度慢，并提出了一种条件交叉注意力机制，用于快速 DETR 训练。我们的方法是基于 DETR 中的交叉注意力高度依赖于内容嵌入来定位四个极值并预测框，这增加了对高质量内容嵌入的需求，从而增加了训练难度。我们的方法名为条件 DETR，从解码器嵌入中学习条件空间查询，用于解码器多头交叉注意力。好处是，通过条件空间查询，每个交叉注意力头都能够关注包含不同区域的带，例如，一个物体极值或物体框内的区域。这缩小了用于物体分类和框回归的不同区域的定位空间范围，从而放松了对内容嵌入的依赖，并简化了训练。实证结果表明，对于骨干网络 R50 和 R101，条件 DETR 的收敛速度快 6.7 倍，对于更强的骨干网络 DC5-R50 和 DC5-R101，收敛速度快 10 倍。代码可在 https://github.com/Atten4Vis/ConditionalDETR 获取。

drawing 与原始 DETR 相比，Conditional DETR 显示出更快的收敛速度。摘自原始论文。

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

资源

ConditionalDetrConfig

class transformers.ConditionalDetrConfig

< >

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

参数

  • use_timm_backbone (bool, 可选, 默认为 True) — 是否使用 timm 库作为骨干网络。如果设置为 False，将使用 AutoBackbone API。
  • backbone_config (PretrainedConfig 或 dict, 可选) — 骨干模型的配置。仅在 use_timm_backbone 设置为 False 时使用，在这种情况下，它将默认为 ResNetConfig()。
  • num_channels (int, 可选, 默认为 3) — 输入通道数。
  • num_queries (int, 可选, 默认为 100) — 对象查询的数量，即检测槽的数量。ConditionalDetrModel 在单张图像中可以检测到的最大对象数量。对于 COCO，我们建议使用 100 个查询。
  • d_model (int, 可选, 默认为 256) — 此参数是一个通用的维度参数，定义了解码器层中编码器层和投影参数等组件的维度。
  • encoder_layers (int, 可选, 默认为 6) — 编码器层数。
  • decoder_layers (int, 可选, 默认为 6) — 解码器层数。
  • encoder_attention_heads (int, 可选, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数。
  • decoder_attention_heads (int, 可选, 默认为 8) — Transformer 解码器中每个注意力层的注意力头数。
  • decoder_ffn_dim (int, 可选, 默认为 2048) — 解码器中“中间”层（通常称为前馈层）的维度。
  • encoder_ffn_dim (int, 可选, 默认为 2048) — 编码器中“中间”层（通常称为前馈层）的维度。
  • activation_function (str 或 function, 可选, 默认为 "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu", "relu", "silu" 和 "gelu_new"。
  • dropout (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
  • activation_dropout (float, 可选, 默认为 0.0) — 全连接层内部激活的 dropout 比率。
  • init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • init_xavier_std (float, 可选, 默认为 1) — 用于 HM 注意力图模块中 Xavier 初始化增益的缩放因子。
  • encoder_layerdrop (float, 可选, 默认为 0.0) — 编码器的 LayerDrop 概率。 有关更多详细信息，请参阅 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。
  • decoder_layerdrop (float, 可选, 默认为 0.0) — 解码器的 LayerDrop 概率。 有关更多详细信息，请参阅 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。
  • auxiliary_loss (bool, 可选, 默认为 False) — 是否使用辅助解码损失（每个解码器层的损失）。
  • position_embedding_type (str, 可选, 默认为 "sine") — 要在图像特征之上使用的位置嵌入类型。可以是 "sine" 或 "learned" 之一。
  • backbone (str, 可选, 默认为 "resnet50") — 当 backbone_config 为 None 时使用的骨干网络名称。如果 use_pretrained_backbone 为 True，这将从 timm 或 transformers 库加载相应的预训练权重。如果 use_pretrained_backbone 为 False，这将加载骨干网络的配置并使用它来初始化具有随机权重的骨干网络。
  • use_pretrained_backbone (bool, 可选, 默认为 True) — 是否为骨干网络使用预训练权重。
  • backbone_kwargs (dict, 可选) — 从检查点加载时要传递给 AutoBackbone 的关键字参数，例如 {'out_indices': (0, 1, 2, 3)}。如果设置了 backbone_config，则无法指定。
  • dilation (bool, 可选, 默认为 False) — 是否在最后一个卷积块 (DC5) 中用空洞卷积替换步幅。仅当 use_timm_backbone = True 时才支持。
  • class_cost (float, 可选, 默认为 1) — 匈牙利匹配成本中分类错误的相对权重。
  • bbox_cost (float, 可选, 默认为 5) — 匈牙利匹配成本中边界框坐标的 L1 误差的相对权重。
  • giou_cost (float, 可选, 默认为 2) — 匈牙利匹配成本中边界框的广义 IoU 损失的相对权重。
  • mask_loss_coefficient (float, 可选, 默认为 1) — 全景分割损失中 Focal 损失的相对权重。
  • dice_loss_coefficient (float, 可选, 默认为 1) — 全景分割损失中 DICE/F-1 损失的相对权重。
  • bbox_loss_coefficient (float, 可选, 默认为 5) — 对象检测损失中 L1 边界框损失的相对权重。
  • giou_loss_coefficient (float, 可选, 默认为 2) — 对象检测损失中广义 IoU 损失的相对权重。
  • eos_coefficient (float, 可选, 默认为 0.1) — 对象检测损失中“无对象”类别的相对分类权重。
  • focal_alpha (float, 可选, 默认为 0.25) — focal 损失中的 Alpha 参数。

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

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

示例

>>> from transformers import ConditionalDetrConfig, ConditionalDetrModel

>>> # Initializing a Conditional DETR microsoft/conditional-detr-resnet-50 style configuration
>>> configuration = ConditionalDetrConfig()

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

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

ConditionalDetrImageProcessor

class transformers.ConditionalDetrImageProcessor

< >

( format: typing.Union[str, transformers.image_utils.AnnotationFormat] = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float]] = None image_std: typing.Union[float, typing.List[float]] = None do_convert_annotations: typing.Optional[bool] = None do_pad: bool = True pad_size: typing.Optional[typing.Dict[str, int]] = None **kwargs )

参数

  • format (str, 可选, 默认为 "coco_detection") — 标注的数据格式。 可以是 “coco_detection” 或 “coco_panoptic” 之一。
  • do_resize (bool, 可选, 默认为 True) — 控制是否将图像的（高度，宽度）尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 参数覆盖。
  • size (Dict[str, int] 可选, 默认为 {"shortest_edge" -- 800, "longest_edge": 1333}): 调整大小后图像的 (height, width) 尺寸。可以被 preprocess 方法中的 size 参数覆盖。 可用选项包括：
    • {"height": int, "width": int}: 图像将被调整为精确尺寸 (height, width)。 不会保持宽高比。
    • {"shortest_edge": int, "longest_edge": int}: 图像将被调整为最大尺寸，同时保持宽高比，并保持最短边小于或等于 shortest_edge，最长边小于或等于 longest_edge。
    • {"max_height": int, "max_width": int}: 图像将被调整为最大尺寸，同时保持宽高比，并保持高度小于或等于 max_height，宽度小于或等于 max_width。
  • resample (PILImageResampling, 可选, 默认为 PILImageResampling.BILINEAR) — 如果调整图像大小，则使用的重采样滤波器。
  • do_rescale (bool, 可选, 默认为 True) — 控制是否按指定的比例 rescale_factor 缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
  • rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果缩放图像，则使用的比例因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
  • do_normalize — 控制是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean (float 或 List[float], 可选, 默认为 IMAGENET_DEFAULT_MEAN) — 归一化图像时使用的均值。可以是单个值或值列表，每个通道一个值。可以被 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (float 或 List[float], 可选, 默认为 IMAGENET_DEFAULT_STD) — 归一化图像时使用的标准差值。可以是单个值或值列表，每个通道一个值。可以被 preprocess 方法中的 image_std 参数覆盖。
  • do_convert_annotations (bool, 可选, 默认为 True) — 控制是否将标注转换为 DETR 模型期望的格式。 将边界框转换为 (center_x, center_y, width, height) 格式，并在 [0, 1] 范围内。可以被 preprocess 方法中的 do_convert_annotations 参数覆盖。
  • do_pad (bool, 可选, 默认为 True) — 控制是否填充图像。可以被 preprocess 方法中的 do_pad 参数覆盖。 如果为 True，则将使用零填充图像的底部和右侧。如果提供了 pad_size，则图像将被填充到指定的尺寸。 否则，图像将被填充到批次中的最大高度和宽度。
  • pad_size (Dict[str, int], 可选) — 将图像填充到的尺寸 {"height": int, "width" int}。 必须大于任何为预处理提供的图像尺寸。 如果未提供 pad_size，则图像将被填充到批次中最大的高度和宽度。

构建 Conditional Detr 图像处理器。

preprocess

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] annotations: typing.Union[dict[str, typing.Union[int, str, list[dict]]], typing.List[dict[str, typing.Union[int, str, list[dict]]]], NoneType] = None return_segmentation_masks: bool = None masks_path: typing.Union[str, pathlib.Path, NoneType] = None do_resize: typing.Optional[bool] = None size: typing.Optional[typing.Dict[str, int]] = None resample = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Union[int, float, NoneType] = None do_normalize: typing.Optional[bool] = None do_convert_annotations: typing.Optional[bool] = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_pad: typing.Optional[bool] = None format: typing.Union[str, transformers.image_utils.AnnotationFormat, NoneType] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: typing.Union[str, transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None pad_size: typing.Optional[typing.Dict[str, int]] = None **kwargs )

参数

  • images (ImageInput) — 要预处理的图像或一批图像。 期望像素值范围为 0 到 255 的单个或一批图像。 如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
  • annotations (AnnotationType 或 List[AnnotationType], 可选) — 与图像或一批图像关联的标注列表。 如果标注用于对象检测，则标注应为包含以下键的字典：
    • “image_id” (int): 图像 ID。
    • “annotations” (List[Dict]): 图像的标注列表。 每个标注应为一个字典。 图像可以没有标注，在这种情况下，列表应为空。 如果标注用于分割，则标注应为包含以下键的字典：
    • “image_id” (int): 图像 ID。
    • “segments_info” (List[Dict]): 图像的分割列表。 每个分割应为一个字典。 图像可以没有分割，在这种情况下，列表应为空。
    • “file_name” (str): 图像的文件名。
  • return_segmentation_masks (bool, 可选, 默认为 self.return_segmentation_masks) — 是否返回分割掩码。
  • masks_path (str 或 pathlib.Path, 可选) — 包含分割掩码的目录的路径。
  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后图像的 (height, width) 尺寸。 可用选项包括：
    • {"height": int, "width": int}: 图像将被调整为精确尺寸 (height, width)。 不会保持宽高比。
    • {"shortest_edge": int, "longest_edge": int}: 图像将被调整为最大尺寸，同时保持宽高比，并保持最短边小于或等于 shortest_edge，最长边小于或等于 longest_edge。
    • {"max_height": int, "max_width": int}: 图像将被调整为最大尺寸，同时保持宽高比，并保持高度小于或等于 max_height，宽度小于或等于 max_width。
  • resample (PILImageResampling, 可选, 默认为 self.resample) — 调整图像大小时使用的重采样滤波器。
  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否缩放图像。
  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 缩放图像时使用的缩放因子。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
  • do_convert_annotations (bool, 可选, 默认为 self.do_convert_annotations) — 是否将注释转换为模型期望的格式。 将边界框从 (top_left_x, top_left_y, width, height) 格式转换为 (center_x, center_y, width, height) 格式，并使用相对坐标。
  • image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 归一化图像时使用的均值。
  • image_std (float 或 List[float], 可选, 默认为 self.image_std) — 归一化图像时使用的标准差。
  • do_pad (bool, 可选, 默认为 self.do_pad) — 是否填充图像。 如果为 True，则会在图像的底部和右侧填充零。 如果提供了 pad_size，图像将被填充到指定的尺寸。 否则，图像将被填充到批次中最大的高度和宽度。
  • format (str 或 AnnotationFormat, 可选, 默认为 self.format) — 注释的格式。
  • return_tensors (str 或 TensorType, 可选, 默认为 self.return_tensors) — 返回张量的类型。 如果为 None，将返回图像列表。
  • data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。 可以是以下之一：
    • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • 未设置： 使用输入图像的通道维度格式。
  • input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。 如果未设置，则通道维度格式从输入图像推断。 可以是以下之一：
    • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • "none" 或 ChannelDimension.NONE: 图像格式为 (height, width)。
  • pad_size (Dict[str, int], 可选) — 要将图像填充到的尺寸 {"height": int, "width" int}。 必须大于预处理提供的任何图像尺寸。 如果未提供 pad_size，则图像将填充到批次中最大的高度和宽度。

预处理单个图像或一批图像，以便模型可以使用它们。

post_process_object_detection

< >

( outputs threshold: float = 0.5 target_sizes: typing.Union[transformers.utils.generic.TensorType, typing.List[typing.Tuple]] = None top_k: int = 100 ) → List[Dict]

参数

  • outputs (DetrObjectDetectionOutput) — 模型的原始输出。
  • threshold (float, 可选) — 保留对象检测预测的分数阈值。
  • top_k (int, 可选, 默认为 100) — 在通过阈值过滤之前，仅保留前 k 个边界框。

返回值

List[Dict]

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

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

post_process_instance_segmentation

< >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None return_coco_annotation: typing.Optional[bool] = False ) → List[Dict]

参数

  • outputs (ConditionalDetrForSegmentation) — 模型的原始输出。
  • 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 — 形状为 (height, width) 的张量，其中每个像素表示一个 segment_id，或者，如果 return_coco_annotation 设置为 True，则为分割图的 List[List] 游程编码 (RLE)。 如果在 threshold 之上未找到掩码，则设置为 None。
  • segments_info — 包含每个段的附加信息的字典。
    • id — 表示 segment_id 的整数。
    • label_id — 表示与 segment_id 对应的标签/语义类 id 的整数。
    • score — segment_id 段的预测分数。

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

post_process_semantic_segmentation

< >

( outputs target_sizes: typing.List[typing.Tuple[int, int]] = None ) → List[torch.Tensor]

参数

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

返回值

List[torch.Tensor]

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

将 ConditionalDetrForSegmentation 的输出转换为语义分割图。 仅支持 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: typing.Optional[typing.Set[int]] = None target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None ） → List[Dict]

参数

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

返回值

List[Dict]

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

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

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

ConditionalDetrFeatureExtractor

class transformers.ConditionalDetrFeatureExtractor

< >

（ *args **kwargs ）

__call__

< >

（ images **kwargs ）

预处理图像或一批图像。

post_process_object_detection

< >

( outputs threshold: float = 0.5 target_sizes: typing.Union[transformers.utils.generic.TensorType, typing.List[typing.Tuple]] = None top_k: int = 100 ) → List[Dict]

参数

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

返回值

List[Dict]

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

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

post_process_instance_segmentation

< >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None return_coco_annotation: typing.Optional[bool] = False ) → List[Dict]

参数

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

返回值

List[Dict]

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

  • segmentation — 形状为 (height, width) 的张量，其中每个像素表示一个 segment_id，或者，如果 return_coco_annotation 设置为 True，则为分割图的 List[List] 游程编码 (RLE)。 如果在 threshold 之上未找到掩码，则设置为 None。
  • segments_info — 包含每个段的附加信息的字典。
    • id — 表示 segment_id 的整数。
    • label_id — 表示与 segment_id 对应的标签/语义类 id 的整数。
    • score — segment_id 段的预测分数。

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

post_process_semantic_segmentation

< >

( outputs target_sizes: typing.List[typing.Tuple[int, int]] = None ) → List[torch.Tensor]

参数

  • outputs (ConditionalDetrForSegmentation) — 模型的原始输出。
  • target_sizes (List[Tuple[int, int]], optional) — 元组列表 (Tuple[int, int])，其中包含批次中每张图像的目标大小（高度，宽度）。如果未设置，则不会调整预测大小。

返回值

List[torch.Tensor]

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

将 ConditionalDetrForSegmentation 的输出转换为语义分割图。 仅支持 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: typing.Optional[typing.Set[int]] = None target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None ） → List[Dict]

参数

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

返回值

List[Dict]

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

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

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

ConditionalDetrModel

class transformers.ConditionalDetrModel

< >

( config: ConditionalDetrConfig )

参数

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

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

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。

forward

< >

( pixel_values: FloatTensor pixel_mask: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None encoder_outputs: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrModelOutput 或 tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供填充，默认情况下会忽略填充。

    像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 ConditionalDetrImageProcessor.call()。

  • pixel_mask (torch.LongTensor，形状为 (batch_size, height, width), 可选) — 用于避免对填充像素值执行注意力的掩码。在 [0, 1] 中选择的掩码值：

    • 1 代表真实像素（即未掩码），
    • 0 代表填充像素（即已掩码）。

    什么是注意力掩码？

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

返回值

transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrModelOutput 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (ConditionalDetrConfig) 和输入。

  • 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 之后，用于计算自注意力头中的加权平均值。
  • intermediate_hidden_states (torch.FloatTensor，形状为 (config.decoder_layers, batch_size, sequence_length, hidden_size), 可选, 当 config.auxiliary_loss=True 时返回) — 中间解码器激活，即每个解码器层的输出，每个解码器层都经过 layernorm。
  • reference_points (torch.FloatTensor，形状为 (config.decoder_layers, batch_size, num_queries, 2 (锚点))) — 参考点（解码器每一层的参考点）。

ConditionalDetrModel forward 方法，覆盖了 __call__ 特殊方法。

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

示例

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> model = AutoModel.from_pretrained("microsoft/conditional-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, 300, 256]

ConditionalDetrForObjectDetection

class transformers.ConditionalDetrForObjectDetection

< >

( config: ConditionalDetrConfig )

参数

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

CONDITIONAL_DETR 模型（由骨干网络和编码器-解码器 Transformer 组成），顶部带有对象检测头，用于执行诸如 COCO 检测之类的任务。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。

forward

< >

( pixel_values: FloatTensor pixel_mask: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None encoder_outputs: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[typing.List[dict]] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrObjectDetectionOutput 或 tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供填充，默认情况下会忽略填充。

    像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 ConditionalDetrImageProcessor.call()。

  • pixel_mask (torch.LongTensor，形状为 (batch_size, height, width), 可选) — 用于避免对填充像素值执行注意力的掩码。在 [0, 1] 中选择的掩码值：

    • 1 代表真实像素（即未掩码），
    • 0 代表填充像素（即已掩码）。

    什么是注意力掩码？

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

返回值

transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrObjectDetectionOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrObjectDetectionOutput 或 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (ConditionalDetrConfig) 和输入。

  • loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 总损失，作为类别预测的负对数似然 (交叉熵) 和边界框损失的线性组合。 后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
  • loss_dict (Dict，可选) — 包含各个损失的字典。 用于日志记录。
  • logits (形状为 (batch_size, num_queries, num_classes + 1) 的 torch.FloatTensor) — 所有 queries 的分类 logits (包括无对象)。
  • pred_boxes (形状为 (batch_size, num_queries, 4) 的 torch.FloatTensor) — 所有 queries 的归一化框坐标，表示为 (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 (形状为 (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 (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 之后，用于计算自注意力头中的加权平均值。

ConditionalDetrForObjectDetection forward 方法，覆盖了 __call__ 特殊方法。

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

示例

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> model = AutoModelForObjectDetection.from_pretrained("microsoft/conditional-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.5, target_sizes=target_sizes)[
...     0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected remote with confidence 0.833 at location [38.31, 72.1, 177.63, 118.45]
Detected cat with confidence 0.831 at location [9.2, 51.38, 321.13, 469.0]
Detected cat with confidence 0.804 at location [340.3, 16.85, 642.93, 370.95]
Detected remote with confidence 0.683 at location [334.48, 73.49, 366.37, 190.01]
Detected couch with confidence 0.535 at location [0.52, 1.19, 640.35, 475.1]

ConditionalDetrForSegmentation

class transformers.ConditionalDetrForSegmentation

< >

( config: ConditionalDetrConfig )

参数

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

CONDITIONAL_DETR 模型 (由 backbone 和编码器-解码器 Transformer 组成)，顶部带有分割头，用于诸如 COCO 全景分割之类的任务。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。

forward

< >

( pixel_values: FloatTensor pixel_mask: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.FloatTensor] = None encoder_outputs: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[typing.List[dict]] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrSegmentationOutput 或 tuple(torch.FloatTensor)

参数

  • pixel_values (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。 默认情况下，如果您提供填充，则会忽略填充。

    像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 ConditionalDetrImageProcessor.call()。

  • pixel_mask (形状为 (batch_size, height, width) 的 torch.LongTensor，可选) — 用于避免对填充像素值执行注意力的掩码。 在 [0, 1] 中选择的掩码值：

    • 1 表示真实像素 (即 未被掩码)，
    • 0 表示填充像素 (即 被掩码)。

    什么是注意力掩码？

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

返回值

transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrSegmentationOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrSegmentationOutput 或 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (ConditionalDetrConfig) 和输入。

  • loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 总损失，作为类别预测的负对数似然 (交叉熵) 和边界框损失的线性组合。 后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。
  • loss_dict (Dict，可选) — 包含各个损失的字典。 用于日志记录。
  • logits (形状为 (batch_size, num_queries, num_classes + 1) 的 torch.FloatTensor) — 所有 queries 的分类 logits (包括无对象)。
  • pred_boxes (形状为 (batch_size, num_queries, 4) 的 torch.FloatTensor) — 所有 queries 的归一化框坐标，表示为 (center_x, center_y, width, height)。 这些值在 [0, 1] 范围内归一化，相对于批次中每个单独图像的大小 (忽略可能的填充)。 您可以使用 post_process_object_detection() 来检索未归一化的边界框。
  • pred_masks (形状为 (batch_size, num_queries, height/4, width/4) 的 torch.FloatTensor) — 所有 queries 的分割掩码 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 (形状为 (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 (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 之后，用于计算自注意力头中的加权平均值。

The ConditionalDetrForSegmentation forward 方法，覆盖了 __call__ 特殊方法。

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

示例

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

>>> from transformers import (
...     AutoImageProcessor,
...     ConditionalDetrConfig,
...     ConditionalDetrForSegmentation,
... )
>>> from transformers.image_transforms import rgb_to_id

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")

>>> # randomly initialize all weights of the model
>>> config = ConditionalDetrConfig()
>>> model = ConditionalDetrForSegmentation(config)

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

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

>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])
>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]
< > Update on GitHub

←BiT ConvNeXT→