Hugging Face's logo

Transformers documentation

RF-DETR

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2024-07-24 在 HF papers 上发布，并于 2026-05-07 贡献至 Hugging Face Transformers。

PyTorch

RF-DETR

RF-DETR 提出了一种感受野检测 Transformer（DETR）架构，旨在与主流的 YOLO 系列竞争并在实时目标检测中超越它。该架构通过结合最新的 Transformer 进展与高效的设计选择，在速度（延迟）和精度（mAP）之间实现了新的最先进平衡。

RF-DETR 架构以其简洁高效的架构为特点：一个 DINOv2 Backbone、一个 Projector 以及一个浅层 DETR Decoder。 它通过以下核心修改来增强 DETR 架构的效率和速度：

  1. DINOv2 骨干网络：使用强大的 DINOv2 骨干网络进行鲁棒的特征提取。
  2. Group DETR 训练：在训练过程中使用 Group-Wise One-to-Many Assignment 以加速收敛。
  3. 更丰富的输入：聚合骨干网络的多层级特征，并使用 C2f Projector（与 YOLOv8 类似）来传递多尺度特征。
  4. 更快的解码器：采用浅层 3 层 DETR 解码器，并结合可变形交叉注意力机制，以降低延迟。
  5. 优化查询：采用混合查询方案，结合可学习的内容查询和生成的空间查询。

您可以在 Roboflow 组织下找到所有可用的 RF-DETR 检查点。 原始代码可在此处找到。

得益于权重转换映射，RfDetr 兼容来自原始 rf-detr 库的模型，以及使用 Roboflow 平台训练的模型。这意味着您可以使用 Roboflow 平台训练模型，并在 transformers 中使用 RfDetr 导入权重，从而在任何地方部署您的模型。

点击右侧边栏中的 RF-DETR 模型，以查看更多将 RF-DETR 应用于不同目标检测任务的示例。

以下示例演示了如何使用 Pipeline 和 AutoModel 类执行目标检测。

Pipeline
AutoModel
from transformers import pipeline
import torch

pipeline = pipeline("object-detection", model="Roboflow/rf-detr-medium", device_map="auto")

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

使用监督信号可视化结果

你可以使用 supervision 库来可视化检测和分割结果。使用 pip install supervision 进行安装。

目标检测
实例分割
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from PIL import Image
import supervision as sv

from huggingface_hub.utils import httpx
from io import BytesIO
import torch

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(BytesIO(httpx.get(url).content))

image_processor = AutoImageProcessor.from_pretrained("Roboflow/rf-detr-medium")
model = AutoModelForObjectDetection.from_pretrained("Roboflow/rf-detr-medium", device_map="auto")

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.height, image.width]), threshold=0.3
)[0]

detections = sv.Detections.from_transformers(
    transformers_results=results, id2label=model.config.id2label
)

box_annotator = sv.BoxAnnotator()
label_annotator = sv.LabelAnnotator()

annotated_image = image.copy()
annotated_image = box_annotator.annotate(annotated_image, detections)
annotated_image = label_annotator.annotate(annotated_image, detections)

sv.plot_image(annotated_image)

资源

RfDetrConfig

类 transformers.RfDetrConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonehidden_expansion: float = 0.5c2f_num_blocks: int = 3activation_function: str = 'silu'dropout: float = 0.1decoder_ffn_dim: int = 2048decoder_n_points: int = 4decoder_layers: int = 3decoder_self_attention_heads: int = 8decoder_cross_attention_heads: int = 16decoder_activation_function: str = 'relu'num_queries: int = 300attention_bias: bool = Trueattention_dropout: float | int = 0.0activation_dropout: float | int = 0.0group_detr: int = 13init_std: float = 0.02disable_custom_kernels: bool = Trueclass_cost: int | float = 2bbox_cost: int | float = 5giou_cost: int | float = 2class_loss_coefficient: int | float = 1dice_loss_coefficient: int | float = 1bbox_loss_coefficient: int | float = 5giou_loss_coefficient: int | float = 2eos_coefficient: float = 0.1focal_alpha: float = 0.25auxiliary_loss: bool = Trued_model: int = 256layer_norm_eps: float = 1e-05num_feature_levels: int = 1mask_loss_coefficient: int | float = 1mask_point_sample_ratio: int = 16mask_downsample_ratio: int = 4mask_class_loss_coefficient: int | float = 5.0mask_dice_loss_coefficient: int | float = 5.0segmentation_head_activation_function: str = 'gelu'intermediate_size: int = 1024 )

参数

  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig]，可选) — 主干模型的配置。
  • hidden_expansion (float，可选，默认为 0.5) — 投影层中隐藏维度的扩展因子。
  • c2f_num_blocks (int，可选，默认为 3) — C2F 层中的块数。
  • activation_function (str，可选，默认为 "silu") — 投影器中使用的非线性激活函数。支持的取值为 "silu"、"relu"、"gelu"。
  • dropout (float，可选，默认值为 0.1) — 所有 dropout 层的比率。
  • decoder_ffn_dim (int，可选，默认为 2048) — 解码器中“中间”（通常称为前馈）层的维度。
  • decoder_n_points (int，可选，默认为 4) — 解码器中每个注意力头在每个特征层级上采样的键数量。
  • decoder_layers (int, 可选，默认为 3) — Transformer 中解码器层的数量。
  • decoder_self_attention_heads (int，可选，默认为 8) — 解码器自注意力中每个注意力层的注意力头数量。
  • decoder_cross_attention_heads (int, 可选，默认为 16) — 解码器交叉注意力中每个注意力层的注意力头数量。
  • decoder_activation_function (str，可选，默认为 "relu") — 解码器中的非线性激活函数。支持的值为 "relu"、"silu"、"gelu"。
  • num_queries (int, 可选，默认为 300) — 对象查询的数量，即检测槽位。这是 RfDetrModel 在单张图像中可检测到的最大对象数量。
  • attention_bias (bool，可选，默认为 True) — 在自注意力机制中，是否在查询、键、值以及输出投影层中使用偏置。
  • attention_dropout (Union[float, int]，可选，默认为 0.0) — 注意力概率的 dropout 比率。
  • activation_dropout (Union[float, int]，可选，默认为 0.0) — 全连接层中激活值的 dropout 比率。
  • group_detr (int, 可选，默认为 13) — Group DETR 注意力机制的组数，有助于降低计算复杂度。
  • init_std (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • disable_custom_kernels (bool，可选，默认为 True) — 禁用自定义 CUDA 和 CPU 内核。此选项对于 ONNX 导出是必需的，因为 PyTorch ONNX 导出不支持自定义内核。
  • class_cost (Union[int, float]，可选，默认为 2) — 匈牙利匹配代价中分类错误的相对权重。
  • bbox_cost (Union[int, float]，可选，默认为 5) — 匈牙利匹配代价中 L1 边界框误差的相对权重。
  • giou_cost (Union[int, float]，可选，默认为 2) — 匈牙利匹配代价中广义 IoU 损失的相对权重。
  • class_loss_coefficient (float，可选，默认为 1) — 匈牙利匹配代价中分类损失的相对权重。
  • 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 loss 中的 Alpha 参数。
  • auxiliary_loss (bool，可选，默认为 True) — 是否使用辅助解码损失（即每个解码器层的损失）。
  • d_model (int，可选，默认为 256) — 编码器层和池化层的维度大小。
  • layer_norm_eps (float，可选，默认为 1e-05) — 层归一化层所使用的 epsilon 值。
  • num_feature_levels (int, 可选，默认为 1) — 多尺度可变形注意力中使用的特征层数。
  • mask_loss_coefficient (float，可选，默认为 1) — 实例分割掩码损失中 Focal loss 的相对权重。
  • mask_point_sample_ratio (int，可选，默认值为 16) — 用于计算掩码损失的采样点比例。
  • mask_downsample_ratio (int，可选，默认为 4) — 分割掩码相对于输入图像分辨率的下采样比例。
  • mask_class_loss_coefficient (float，可选，默认值为 5.0) — 实例分割损失中 Focal loss 的相对权重。
  • mask_dice_loss_coefficient (float, 可选，默认值为 5.0) — 实例分割损失中 DICE/F-1 损失的相对权重。
  • segmentation_head_activation_function (str，可选，默认为 "gelu") — 分割头中的非线性激活函数。支持的值为 "relu"、"silu"、"gelu"。
  • intermediate_size (int，可选，默认为 1024) — MLP 表示的维度。

这是用于存储 RfDetrModel 配置的类。它根据指定的参数实例化 Rf Detr 模型，并定义模型架构。使用默认值实例化配置将生成与 Roboflow/rf-detr-base 类似的配置。

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

示例：

>>> from transformers import RfDetrConfig, RfDetrModel

>>> # Initializing a RF-DETR roboflow/rf-detr-base style configuration
>>> configuration = RfDetrConfig()

>>> # Initializing a model (with random weights) from the Roboflow/rf-detr-base style configuration
>>> model = RfDetrModel(configuration)

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

RfDetrDinov2Config

类 transformers.RfDetrDinov2Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12mlp_ratio: int = 4hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06image_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 14num_channels: int = 3qkv_bias: bool = Truelayerscale_value: float = 1.0drop_path_rate: float | int = 0.0use_swiglu_ffn: bool = False_out_features: list[str] | None = None_out_indices: list[int] | None = Noneapply_layernorm: bool = Truereshape_hidden_states: bool = Trueuse_mask_token: bool = Truenum_windows: int = 4 )

参数

  • hidden_size (int，可选，默认为 768) — 隐藏表示的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int，可选，默认为 12) — Transformer 解码器中每个注意力层的注意力头数量。
  • mlp_ratio (int，可选，默认为 4) — MLP 隐藏层维度与嵌入维度的比值。
  • hidden_act (str，可选，默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • hidden_dropout_prob (Union[float, int]，可选，默认为 0.0) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
  • attention_probs_dropout_prob (Union[float, int]，可选，默认为 0.0) — 注意力概率的 dropout 比率。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float，可选，默认为 1e-06) — 层归一化层所使用的 epsilon 值。
  • image_size (Union[int, list[int], tuple[int, int]]，可选，默认为 224) — 每张图片的尺寸（分辨率）。
  • patch_size (Union[int, list[int], tuple[int, int]]，可选，默认为 14) — 每个 patch 的大小（分辨率）。
  • num_channels (int，可选，默认为 3) — 输入通道的数量。
  • qkv_bias (bool，可选，默认为 True) — 是否向查询、键和值添加偏置。
  • layerscale_value (float，可选，默认为 1.0) — 用于 layer scale 的初始值。
  • drop_path_rate (float，可选，默认值为 0.0) — 每个样本的随机深度率（当应用于残差层的主路径时）。
  • use_swiglu_ffn (bool，可选，默认为 False) — 是否使用 SwiGLU 前馈神经网络。
  • apply_layernorm (bool，可选，默认为 True) — 当模型用作 backbone 时，是否对特征图应用层归一化。
  • reshape_hidden_states (bool，可选，默认为 True) — 当模型用作骨干网络时，是否将特征图重塑为形状为 (batch_size, d_model, height, width) 的 4D 张量。如果为 False，则特征图将是形状为 (batch_size, seq_len, d_model) 的 3D 张量。
  • use_mask_token (bool，可选，默认为 True) — 是否在嵌入中使用 mask_token。
  • num_windows (int，可选，默认为 4) — 用于窗口注意力的窗口数量。如果为 1，则不使用窗口注意力。

这是用于存储 RfDetrModel 配置的类。它根据指定的参数实例化 Rf Detr 模型，并定义模型架构。使用默认值实例化配置将生成与 Roboflow/rf-detr-base 类似的配置。

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

示例：

>>> from transformers import RfDetrDinov2Config, RfDetrDinov2Backbone

>>> # Initializing a RfDetrDinov2 base style configuration
>>> configuration = RfDetrDinov2Config()

>>> # Initializing a model (with random weights) from the base style configuration
>>> model = RfDetrDinov2Backbone(configuration)

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

RfDetrImageProcessor

class transformers.RfDetrImageProcessor

< >

( **kwargs: *<class 'transformers.models.rf_detr.image_processing_rf_detr.RfDetrImageProcessorKwargs'> )

参数

  • 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 为 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，默认为 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, optional, 默认为 AnnotationFormat.COCO_DETECTION) — 标注的数据格式。取值为 “coco_detection” 或 “coco_panoptic” 之一。
  • do_convert_annotations (bool, kwargs, 可选，默认为 True) — 控制是否将标注转换为 RF_DETR 模型所期望的格式。将边界框转换为 (center_x, center_y, width, height) 格式，且取值范围为 [0, 1]。可通过 preprocess 方法中的 do_convert_annotations 参数进行覆盖。

构建一个 RfDetrImageProcessor 图像处理器。

预处理

< >

( 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 = Nonereturn_segmentation_masks: bool | None = Nonemasks_path: str | pathlib.Path | None = None**kwargs: *<class 'transformers.models.rf_detr.image_processing_rf_detr.RfDetrImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

参数

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — 要预处理的图像。期望输入单张图像或一批图像，其像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间，请设置 do_rescale=False。
  • annotations（AnnotationType 或 list[AnnotationType]，可选）— 根据应用于图像的填充进行转换的注释。
  • 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 为整数时，是否在调整大小时默认使用正方形图像。
  • 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, optional, 默认为 AnnotationFormat.COCO_DETECTION) — 标注的数据格式。取值为 “coco_detection” 或 “coco_panoptic” 之一。
  • do_convert_annotations (bool, kwargs, 可选，默认为 True) — 控制是否将标注转换为 RF_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

< >

( outputsthreshold: float = 0.5target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = Nonetop_k: int | None = None ) → list[Dict]

参数

  • outputs (RfDetrObjectDetectionOutput) — 模型的原始输出。
  • threshold (float, 可选) — 用于保留目标检测预测结果的分数阈值。
  • target_sizes (torch.Tensor 或 list[tuple[int, int]]，可选) — 形状为 (batch_size, 2) 的张量，或包含目标尺寸 (height, width) 的元组列表（tuple[int, int]），表示批次中每张图片的目标大小。如果未设置，预测结果将不会被调整大小。

返回值

list[Dict]

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

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

post_process_instance_segmentation

< >

( outputsthreshold: float = 0.5mask_threshold: float = 0.0target_sizes: list[tuple[int, int]] | None = Nonereturn_coco_annotation: bool = Falsereturn_binary_maps: bool = Falsetop_k: int | None = None**kwargs ) → list[dict]

参数

  • outputs ([RfDetrInstanceSegmentationOutput]) — 模型的原始输出。
  • threshold (float，可选，默认为 0.5) — 用于保留预测实例掩码的分数阈值。
  • mask_threshold (float，可选，默认为 0.0) — 用于将预测掩码二值化的阈值。
  • target_sizes (list[tuple[int, int]], 可选) — 每张图像的(height, width)目标尺寸。如果未设置，掩码将不会被调整大小。
  • return_coco_annotation (bool，可选，默认为 False) — 如果为 True，则以 COCO 游程编码格式返回分割图，而不是张量。 与 return_binary_maps 互斥。
  • return_binary_maps (bool，可选，默认为 False) — 如果为 True，则返回分割图，格式为堆叠的二值实例掩码张量（每个检测到的实例对应一个），且不进行重叠消解。这与原始 rfdetr 包的输出格式一致。与 return_coco_annotation 互斥。
  • top_k (int, 可选) — 在应用分数阈值之前评估的最大候选查询数量。 默认值为查询的总数。

返回值

list[dict]

每张图片对应一个字典，包含以下键：

  • segmentation — Tensor[H, W] 的 int32 段 ID（-1 = 背景）， 当 return_binary_maps=True 时为 Tensor[num_instances, H, W] 的布尔二值掩码， 或当 return_coco_annotation=True 时为 RLE 编码列表。
  • segments_info — 一个字典列表，包含键 id、label_id 和 score。

将 [RfDetrForInstanceSegmentation] 的输出转换为实例分割预测结果。

RfDetrModel

class transformers.RfDetrModel

< >

( config: RfDetrConfig )

参数

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

原始的 LW Detr 模型（由骨干网络和解码器 Transformer 组成），输出未经任何特定头部处理的原始隐藏状态。

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( pixel_values: Tensorpixel_mask: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → RfDetrModelOutput or tuple(torch.Tensor)

参数

  • pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)) — 对应输入图像的张量。可以使用 RfDetrImageProcessor 获取像素值。有关详细信息，请参阅 RfDetrImageProcessor.call()（processor_class 使用 RfDetrImageProcessor 处理图像）。
  • pixel_mask (torch.LongTensor 形状为 (batch_size, height, width), 可选) — 用于避免对填充像素值执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 对于真实的像素（即未被掩码的像素），值为 1，
    • 对于填充像素（即 被屏蔽 的像素），值为 0。

    什么是注意力掩码？

返回值

RfDetrModelOutput 或 tuple(torch.Tensor)

RfDetrModelOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（RfDetrConfig）和输入。

RF-DETR 模型的前向传播过程。该流程如下：

  1. 从骨干网络的展平输出中生成初始的对象查询嵌入和空间位置建议。
  2. 初始化用于存储精炼后的编码器阶段预测结果的存储空间（以适配多组查询结构），并针对每个查询组迭代地精炼对象查询及其坐标，从而捕获编码器阶段中置信度最高的候选目标。
  3. 初始化可学习的查询特征和空间参考点（在推理阶段，为提高效率，仅限制在主组内）。
  4. 将基础参考点投影到整个批次，使用预测的坐标细化值对其进行优化（在解码前将注意力转移到已发现的物体位置），并将目标查询特征扩展以匹配批次维度。
  5. 将精炼后的查询和更新后的参考点通过 Transformer 解码器，以从多尺度特征中聚合详细的空间上下文。

  • last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选）— 模型最后一层输出的隐藏状态序列。

  • init_reference_points（形状为 (batch_size, num_queries, 4) 的 torch.Tensor）— 通过 Transformer 解码器传输的初始参考点。

  • intermediate_hidden_states（形状为 (batch_size, config.decoder_layers, num_queries, d_model) 的 torch.Tensor）— 堆叠的中间隐藏状态（解码器每一层的输出）。

  • intermediate_reference_points（形状为 (batch_size, config.decoder_layers, num_queries, 4) 的 torch.Tensor）— 堆叠的中间参考点（解码器每一层的参考点）。

  • enc_outputs_class (torch.Tensor，形状为 (batch_size, sequence_length, config.num_labels)，可选，当 config.with_box_refine=True 且 config.two_stage=True 时返回) — 预测的边界框分数，其中得分最高的 config.two_stage_num_proposals 个边界框在第一阶段被选为区域建议。边界框二分类（即前景和背景）的输出。

  • enc_outputs_coord_logits (torch.Tensor，形状为 (batch_size, sequence_length, 4)，可选，当 config.with_box_refine=True 且 config.two_stage=True 时返回) — 第一阶段中预测的边界框坐标的 logits。

  • hidden_states (tuple[torch.Tensor, ...]，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

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

  • backbone_features（形状为 (batch_size, config.num_channels, config.image_size, config.image_size) 的 torch.Tensor 的 list）— 来自骨干网络的特征。

示例：

>>> from transformers import AutoImageProcessor, RfDetrModel
>>> 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("Roboflow/rf-detr-base")
>>> model = RfDetrModel.from_pretrained("Roboflow/rf-detr-base")

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

>>> outputs = model(**inputs)

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

RfDetrForObjectDetection

class transformers.RfDetrForObjectDetection

< >

( config: RfDetrConfig )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( pixel_values: Tensor = Nonepixel_mask: typing.Optional[torch.LongTensor] = Nonelabels: list[dict] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → RfDetrObjectDetectionOutput or tuple(torch.Tensor)

参数

  • pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。可以使用 RfDetrImageProcessor 获取像素值。有关详细信息，请参阅 RfDetrImageProcessor.call()（processor_class 使用 RfDetrImageProcessor 处理图像）。
  • pixel_mask (torch.LongTensor 形状为 (batch_size, height, width), 可选) — 用于避免对填充像素值执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 对于真实的像素（即未被掩码的像素），值为 1，
    • 对于填充像素（即 被屏蔽 的像素），值为 0。

    什么是注意力掩码？

  • 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。

返回值

RfDetrObjectDetectionOutput 或 tuple(torch.Tensor)

RfDetrObjectDetectionOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（RfDetrConfig）和输入。

前向传播过程如下：

  1. 通过基础 RF-DETR 模型处理视觉输入，以获取 Transformer 的最后一个隐藏状态以及最终的参考点序列。
  2. 第一阶段：从编码器提出的对象查询嵌入生成分类 logits。
  3. 第二阶段：使用解码器的最后一个隐藏状态以及最近的参考点，预测最终的分类标签和精化的边界框

  • 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] 范围内归一化，相对于批次中每张图片的单独尺寸（忽略可能的填充）。您可以使用 ~DeformableDetrProcessor.post_process_object_detection 来获取未归一化的边界框。

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

  • init_reference_points（形状为 (batch_size, num_queries, 4) 的 torch.Tensor）— 通过 Transformer 解码器传输的初始参考点。

  • last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选）— 模型最后一层输出的隐藏状态序列。

  • intermediate_hidden_states（形状为 (batch_size, config.decoder_layers, num_queries, d_model) 的 torch.Tensor）— 堆叠的中间隐藏状态（解码器每一层的输出）。

  • intermediate_reference_points（形状为 (batch_size, config.decoder_layers, num_queries, 4) 的 torch.Tensor）— 堆叠的中间参考点（解码器每一层的参考点）。

  • enc_outputs_class (torch.Tensor，形状为 (batch_size, sequence_length, config.num_labels)，可选，当 config.with_box_refine=True 且 config.two_stage=True 时返回) — 预测的边界框分数，其中得分最高的 config.two_stage_num_proposals 个边界框在第一阶段被选为区域建议。边界框二分类（即前景和背景）的输出。

  • enc_outputs_coord_logits (torch.Tensor，形状为 (batch_size, sequence_length, 4)，可选，当 config.with_box_refine=True 且 config.two_stage=True 时返回) — 第一阶段中预测的边界框坐标的 logits。

  • hidden_states (tuple[torch.Tensor, ...]，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

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

  • backbone_features（形状为 (batch_size, config.num_channels, config.image_size, config.image_size) 的 torch.Tensor 的 list）— 来自骨干网络的特征。

示例：

>>> from transformers import AutoImageProcessor, RfDetrForObjectDetection
>>> 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("Roboflow/rf-detr-base")
>>> model = RfDetrForObjectDetection.from_pretrained("Roboflow/rf-detr-base")

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

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
...     0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected cat with confidence 0.8 at location [16.5, 52.84, 318.25, 470.78]
Detected cat with confidence 0.789 at location [342.19, 24.3, 640.02, 372.25]
Detected remote with confidence 0.633 at location [40.79, 72.78, 176.76, 117.25]

RfDetrForInstanceSegmentation

class transformers.RfDetrForInstanceSegmentation

< >

( config: RfDetrConfig )

forward

< >

( pixel_values: Tensor = Nonepixel_mask: typing.Optional[torch.LongTensor] = Nonelabels: list[dict] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

参数

  • pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。可以使用 RfDetrImageProcessor 获取像素值。有关详细信息，请参阅 RfDetrImageProcessor.call()（processor_class 使用 RfDetrImageProcessor 处理图像）。
  • pixel_mask (torch.LongTensor 形状为 (batch_size, height, width), 可选) — 用于避免对填充像素值执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 对于真实的像素（即未被掩码的像素），值为 1，
    • 对于填充像素（即 被屏蔽 的像素），值为 0。

    什么是注意力掩码？

  • 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。

RF-DETR 模型用于实例分割的前向传播过程。该流程如下：

  1. 通过基础 RF-DETR 模型处理视觉输入，以获取多尺度空间特征、查询嵌入及其变换历史。
  2. 从编码器提出的对象查询嵌入中生成分类 logits 和初始分割掩码（第一阶段）。
  3. 使用解码器的最后一个隐藏状态（第二阶段）预测最终的分类标签和精化的边界框。
  4. 将高分辨率空间特征和查询隐藏状态通过分割头，以生成最终的详细实例掩码。

RfDetrDinov2Backbone

class transformers.RfDetrDinov2Backbone

< >

( config: RfDetrDinov2Config )

参数

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

RfDetrDinov2 骨干网络，用于与 DETR 和 MaskFormer 等框架配合使用。

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BackboneOutput or tuple(torch.Tensor)

参数

返回值

BackboneOutput 或 tuple(torch.Tensor)

BackboneOutput 或 torch.Tensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（RfDetrConfig）和输入。

RfDetrDinov2Backbone 的 forward 方法重写了 __call__ 特殊方法。

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

  • feature_maps（形状为 (batch_size, num_channels, height, width) 的 tuple(torch.Tensor)）— 各阶段的特征图。

  • hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（包含嵌入层的输出以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size) 或 (batch_size, num_channels, height, width)，具体取决于骨干网络。

    模型在每个阶段输出处的隐藏状态，以及初始嵌入输出。

  • attentions (tuple(torch.Tensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。仅当主干网络使用注意力机制时适用。

    注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。

示例：

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

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

>>> processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
>>> model = AutoBackbone.from_pretrained(
...     "facebook/dinov2-base", out_features=["stage2", "stage5", "stage8", "stage11"]
... )

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

>>> outputs = model(**inputs)
>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 768, 16, 16]
Update on GitHub

←ResNet RT-DETR→