# RF-DETR

[RF-DETR](https://github.com/roboflow/rf-detr) предлагает архитектуру Receptive Field Detection Transformer (DETR), разработанную для конкуренции с доминирующей серией YOLO и превосходства над ней в задачах детектирования объектов в реальном времени. Она достигает нового рекордного баланса между скоростью (латентностью) и точностью (mAP), сочетая последние достижения в области трансформеров с эффективными решениями в проектировании.

Архитектура RF-DETR характеризуется простой и эффективной структурой: DINOv2 Backbone, Projector и неглубокий DETR Decoder. Она улучшает архитектуру DETR с точки зрения эффективности и скорости, используя следующие ключевые модификации:

1. **Backbone DINOv2**: Использует мощный backbone DINOv2 для надежного извлечения признаков.
2. **Обучение Group DETR**: использует Group-Wise One-to-Many Assignment на этапе обучения для ускорения сходимости.
3. **Более богатый вход**: агрегирует многоуровневые признаки из backbone и использует проектор C2f (аналогично YOLOv8) для передачи многомасштабных признаков.
4. **Faster Decoder**: использует неглубокий 3-слойный декодер DETR с деформируемым кросс-вниманием для снижения задержки.
5. **Оптимизированные запросы**: Используется схема смешанных запросов, объединяющая обучаемые контентные запросы и генерируемые пространственные запросы.

Все доступные контрольные точки RF-DETR можно найти в организации [Roboflow](https://huggingface.co/Roboflow). Исходный код доступен [здесь](https://github.com/roboflow/rf-detr).

Благодаря маппингу весов RfDetr совместим с моделями из исходной библиотеки [rf-detr](https://github.com/roboflow/rf-detr), а также с моделями, обученными на платформе [Roboflow](https://roboflow.com/). Это означает, что вы можете обучать модель на платформе Roboflow, а затем использовать `RfDetr` в `transformers` для импорта весов и развертывания модели в любом окружении.

> [!TIP]
>
> Щёлкните по моделям RF-DETR в боковой панели справа, чтобы увидеть больше примеров применения RF-DETR к различным задачам обнаружения объектов.

Приведённый ниже пример демонстрирует, как выполнять обнаружение объектов с помощью [Pipeline](/docs/transformers/v5.23.0/ru/main_classes/pipelines#transformers.Pipeline) и класса [AutoModel](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoModel).

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

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from PIL import Image
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")

# 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}")
```

### Визуализация результатов с надзором

Библиотеку [supervision](https://github.com/roboflow/supervision) можно использовать для визуализации результатов обнаружения и сегментации. Установите её с помощью `pip install supervision`.

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

```python
from transformers import AutoImageProcessor, AutoModelForInstanceSegmentation
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-seg-medium")
model = AutoModelForInstanceSegmentation.from_pretrained("Roboflow/rf-detr-seg-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_instance_segmentation(
    outputs, target_sizes=[image.size[::-1]], threshold=0.3
)[0]

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

mask_annotator = sv.MaskAnnotator()
label_annotator = sv.LabelAnnotator()

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

sv.plot_image(annotated_image)
```

## Ресурсы

- См. также: [Руководство по задаче обнаружения объектов](../tasks/object_detection).

## RfDetrConfig[[transformers.RfDetrConfig]]

#### transformers.RfDetrConfig[[transformers.RfDetrConfig]]

```python
transformers.RfDetrConfig(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, is_encoder_decoder: bool = False, 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, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_expansion: float = 0.5, c2f_num_blocks: int = 3, activation_function: str = 'silu', dropout: float = 0.1, decoder_ffn_dim: int = 2048, decoder_n_points: int = 4, decoder_layers: int = 3, decoder_self_attention_heads: int = 8, decoder_cross_attention_heads: int = 16, decoder_activation_function: str = 'relu', num_queries: int = 300, attention_bias: bool = True, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, group_detr: int = 13, init_std: float = 0.02, disable_custom_kernels: bool = True, class_cost: int | float = 2, bbox_cost: int | float = 5, giou_cost: int | float = 2, class_loss_coefficient: int | float = 1, dice_loss_coefficient: int | float = 1, bbox_loss_coefficient: int | float = 5, giou_loss_coefficient: int | float = 2, eos_coefficient: float = 0.1, focal_alpha: float = 0.25, auxiliary_loss: bool = True, d_model: int = 256, layer_norm_eps: float = 1e-05, num_feature_levels: int = 1, mask_loss_coefficient: int | float = 1, mask_point_sample_ratio: int = 16, mask_downsample_ratio: int = 4, mask_class_loss_coefficient: int | float = 5.0, mask_dice_loss_coefficient: int | float = 5.0, segmentation_head_activation_function: str = 'gelu', intermediate_size: int = 1024)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/configuration_rf_detr.py#L103)

**Параметры:**

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`) : Размерность «промежуточного» (часто называемого feed-forward) слоя в декодере.

decoder_n_points (`int`, *optional*, по умолчанию 4) : Количество выбранных ключей на каждом уровне признаков для каждой головы внимания в декодере.

decoder_layers (`int`, *необязательный*, по умолчанию 3) : Количество декодерных слоев в трансформере.

decoder_self_attention_heads (`int`, *optional*, по умолчанию 8) : Количество головок внимания для каждого слоя внимания в само-внимании декодера.

decoder_cross_attention_heads (`int`, *optional*, по умолчанию 16) : Количество головок внимания для каждого слоя кросс-внимания в декодере.

decoder_activation_function (`str`, *необязательный*, по умолчанию `"relu"`) : Нелинейная функция активации в декодере. Поддерживаемые значения: `"relu"`, `"silu"`, `"gelu"`.

num_queries (`int`, *optional*, по умолчанию 300) : Количество запросов объектов, то есть слотов для обнаружения. Это максимальное число объектов, которые [RfDetrModel](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrModel) может обнаружить на одном изображении.

attention_bias (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в слоях проекции запроса, ключа, значения и вывода при само-внимании.

attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания.

activation_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для активаций внутри полносвязного слоя.

group_detr (`int`, *optional*, по умолчанию 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`, *optional*, по умолчанию 1) : Относительный вес функции потерь классификации в стоимости венгерского сопоставления.

dice_loss_coefficient (`float`, *необязательный*, по умолчанию 1) : Относительный вес функции потерь DICE/F-1 в общей функции потерь обнаружения объектов.

bbox_loss_coefficient (`float`, *optional*, по умолчанию 5) : Относительный вес потери L1 для ограничивающих прямоугольников в функции потерь обнаружения объектов.

giou_loss_coefficient (`float`, *optional*, по умолчанию 2) : Относительный вес обобщённой функции потерь IoU в функции потерь обнаружения объектов.

eos_coefficient (`float`, *необязательный*, по умолчанию `0.1`) : Относительный вес класса «нет объекта» в функции потерь обнаружения объектов.

focal_alpha (`float`, *необязательный*, по умолчанию `0.25`) : Параметр alpha в функции потерь focal loss.

auxiliary_loss (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли вспомогательные потери декодирования (потери на каждом слое декодера).

d_model (`int`, *необязательный*, по умолчанию `256`) : Размер слоев кодировщика и пулера.

layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-05`) : Значение epsilon, используемое слоями нормализации.

num_feature_levels (`int`, *optional*, по умолчанию 1) : Количество уровней признаков, используемых в многоступенчатом деформируемом внимании.

mask_loss_coefficient (`float`, *optional*, по умолчанию 1) : Относительный вес Focal loss в функции потерь маски для сегментации экземпляров.

mask_point_sample_ratio (`int`, *optional*, по умолчанию 16) : Коэффициент выборки точек для вычисления потерь маски.

mask_downsample_ratio (`int`, *optional*, по умолчанию 4) : Коэффициент downsampling для сегментационных масок относительно разрешения входного изображения.

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](https://huggingface.co/Roboflow/rf-detr-base)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Примеры:

```python
>>> 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.RfDetrDinov2Config[[transformers.RfDetrDinov2Config]]

```python
transformers.RfDetrDinov2Config(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, is_encoder_decoder: bool = False, 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, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, mlp_ratio: int = 4, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 14, num_channels: int = 3, qkv_bias: bool = True, layerscale_value: float = 1.0, drop_path_rate: float | int = 0.0, use_swiglu_ffn: bool = False, _out_features: list[str] | None = None, _out_indices: list[int] | None = None, apply_layernorm: bool = True, reshape_hidden_states: bool = True, use_mask_token: bool = True, num_windows: int = 4)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/configuration_rf_detr.py#L30)

**Параметры:**

hidden_size (`int`, *optional*, по умолчанию `768`) : Размерность скрытых представлений.

num_hidden_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `12`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

mlp_ratio (`int`, *optional*, по умолчанию `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`) : Размер (разрешение) каждого патча.

num_channels (`int`, *необязательный*, по умолчанию `3`) : Количество входных каналов.

qkv_bias (`bool`, *необязательный*, по умолчанию `True`) : Добавлять ли смещение (bias) к запросам, ключам и значениям.

layerscale_value (`float`, *необязательный*, по умолчанию 1.0) : Начальное значение для layer scale.

drop_path_rate (`float`, *необязательный*, по умолчанию 0.0) : Скорость стохастической глубины на каждый образец (когда применяется в основном пути остаточных слоев).

use_swiglu_ffn (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли свёрточную нейронную сеть SwiGLU.

apply_layernorm (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли применять нормализацию слоя к картам признаков, если модель используется в качестве базовой.

reshape_hidden_states (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли преобразовать карты признаков в 4D-тензоры формы `(batch_size, d_model, height, width)`, если модель используется как backbone. Если `False`, карты признаков будут 3D-тензорами формы `(batch_size, seq_len, d_model)`.

use_mask_token (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли mask_token во вложениях.

num_windows (`int`, *optional*, по умолчанию 4) : Количество окон для использования в оконном внимании. Если равно 1, оконное внимание не используется.

Это класс конфигурации для хранения настроек модели RfDetrModel. Он используется для создания модели Rf Detr в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [Roboflow/rf-detr-base](https://huggingface.co/Roboflow/rf-detr-base)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:

```python
>>> 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[[transformers.RfDetrImageProcessor]]

#### transformers.RfDetrImageProcessor[[transformers.RfDetrImageProcessor]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L218)

**Параметры:**

do_convert_rgb (`bool`, *kwargs*, *необязательный*) : Преобразовать ли изображение в RGB.

do_resize (`bool`, *kwargs*, *optional*, по умолчанию `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*, *optional*, по умолчанию `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*, *optional*, по умолчанию `True`) : Нужно ли масштабировать изображение.

rescale_factor (`float`, *kwargs*, *optional*, по умолчанию `0.00392156862745098`) : Коэффициент масштабирования для изменения масштаба изображения, если `do_rescale` установлен в `True`.

do_normalize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли нормализовать изображение.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.485, 0.456, 0.406]`) : Средние значения изображения, используемые для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.229, 0.224, 0.225]`) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

do_pad (`bool`, *kwargs*, *optional*, по умолчанию `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*, *optional*) : Центрировать ли изображение при обрезке.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"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*, *optional*) : Указывает, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробно описанных здесь: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *необязательный*) : Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора.

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]`. Может быть переопределён параметром `do_convert_annotations` в методе `preprocess`.

Создаёт процессор изображений RfDetrImageProcessor.

#### preprocess[[transformers.RfDetrImageProcessor.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.rf_detr.image_processing_rf_detr.RfDetrImageProcessorKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L464)

**Параметры:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Изображение для предобработки. Ожидается одно изображение или пакет изображений со значениями пикселей в диапазоне от 0 до 255. Если передаются изображения со значениями пикселей в диапазоне от 0 до 1, установите `do_rescale=False`.

annotations (`AnnotationType` или `list[AnnotationType]`, *необязательный*) : Аннотации, которые необходимо преобразовать в соответствии с применяемым к изображениям выравниванием (padding).

return_segmentation_masks (`bool`, *необязательный*, по умолчанию `self.return_segmentation_masks`) : Нужно ли возвращать маски сегментации.

masks_path (`str` или `pathlib.Path`, *необязательный*) : Путь к каталогу, содержащему маски сегментации.

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*, *optional*) : Коэффициент масштабирования для изменения размера изображения, если `do_rescale` установлен в `True`.

do_normalize (`bool`, *kwargs*, *необязательный*) : Нужно ли нормализовать изображение.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Среднее значение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `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*, *optional*) : Центрировать ли изображение при обрезке.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"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*, *optional*) : Указывает, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробно описанных здесь: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *необязательный*) : Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора.

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]`. Может быть переопределён параметром `do_convert_annotations` в методе `preprocess`.

**Возвращает:** `~image_processing_base.BatchFeature`

- **data** (`dict`) — Словарь списков/массивов/тензоров, возвращаемый методом __call__ ('pixel_values' и т. д.).
- **tensor_type** (`Union[None, str, TensorType]`, *необязательный*) -- Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy.

#### post_process_object_detection[[transformers.RfDetrImageProcessor.post_process_object_detection]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L606)

**Параметры:**

outputs (`RfDetrObjectDetectionOutput`) : Сырые выходные данные модели.

threshold (`float`, *необязательный*) : Порог оценки для сохранения предсказаний обнаружения объектов.

target_sizes (`torch.Tensor` или `list[tuple[int, int]]`, *необязательный*) : тензор формы `(batch_size, 2)` или список кортежей (`tuple[int, int]`), содержащих целевой размер `(height, width)` каждого изображения в батче. Если не задано, предсказания не будут изменены в размере.

**Возвращает:** `list[Dict]`

Список словарей, где каждый словарь содержит оценки, метки и рамки для изображения в батче, как их предсказала модель.

Преобразует необработанный вывод [RfDetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrForObjectDetection) в итоговые ограничивающие прямоугольники в формате (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Поддерживается только PyTorch.

#### post_process_instance_segmentation[[transformers.RfDetrImageProcessor.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.0, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool = False, return_binary_maps: bool = False, top_k: int | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/image_processing_rf_detr.py#L660)

**Параметры:**

outputs ([*RfDetrInstanceSegmentationOutput*]) : Сырые выходные данные модели.

threshold (*float*, *optional*, по умолчанию 0.5) : Порог оценки для сохранения предсказанных масок экземпляров.

mask_threshold (*float*, *optional*, по умолчанию 0.0) : Порог для бинаризации предсказанных масок.

target_sizes (*list[tuple[int, int]]*, *optional*) : Целевой размер `(height, width)` для каждого изображения. Если не задан, маски не масштабируются.

return_coco_annotation (*bool*, *optional*, по умолчанию *False*) : Если *True*, возвращает карты сегментации в формате COCO run-length encoding вместо тензоров. Взаимоисключающий параметр с *return_binary_maps*.

return_binary_maps (*bool*, *optional*, по умолчанию *False*) : Если *True*, возвращает карты сегментации в виде стека тензоров с бинарными масками инстансов (по одной на каждый обнаруженный инстанс), без разрешения пересечений. Это соответствует формату вывода исходного пакета `rfdetr`. Взаимоисключается с *return_coco_annotation*.

top_k (*int*, *optional*) : Максимальное количество кандидатных запросов, оцениваемых до применения порога по оценке. По умолчанию равно общему числу запросов.

**Возвращает:** *list[dict]*

Один словарь на изображение с ключами:
- **segmentation** -- *Tensor[H, W]* с идентификаторами сегментов типа `int32` (`-1` = фон), *Tensor[num_instances, H, W]* с булевыми бинарными масками, если *return_binary_maps=True*, или список RLE-кодирований, если *return_coco_annotation=True*.
- **segments_info** -- список словарей с ключами `id`, `label_id` и `score`.

Преобразует выход [*RfDetrForInstanceSegmentation*] в предсказания сегментации экземпляров.

## RfDetrModel[[transformers.RfDetrModel]]

#### transformers.RfDetrModel[[transformers.RfDetrModel]]

```python
transformers.RfDetrModel(config: RfDetrConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1330)

**Параметры:**

config ([RfDetrConfig](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель LW Detr без дополнительных компонентов (состоящая из backbone и decoder Transformer), выводящая «сырые» hidden-states без какого-либо специализированного head сверху.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.RfDetrModel.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1437)

**Параметры:**

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [RfDetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrImageProcessor). Подробности см. в [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) (`processor_class` использует [RfDetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrImageProcessor) для обработки изображений).

pixel_mask (`torch.LongTensor` формы `(batch_size, height, width)`, *необязательно*) : Маска для исключения значений пикселей отступов из внимания. Значения маски выбираются из `[0, 1]`:  - 1 для реальных пикселей (т. е. **не замаскированных**), - 0 для пикселей отступов (т. е. **замаскированных**).  [Что такое маски внимания?](../glossary#attention-mask)

**Возвращает:** `RfDetrModelOutput` или `tuple(torch.Tensor)`

Объект `RfDetrModelOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([RfDetrConfig](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrConfig)) и входных данных.

Прямой проход модели RF-DETR. Конвейер выполняется следующим образом:

1. Сгенерируйте начальный набор эмбеддингов запросов объектов и предложений пространственных локаций из сглаженного вывода бэкбона.
2. Инициализируйте хранилище для уточненных предсказаний на этапе энкодера (с учетом многогрупповых структур запросов) и итеративно уточняйте объектные запросы и их координаты для каждой группы запросов, чтобы извлечь кандидатов с наивысшей уверенностью на этапе энкодера.
3. Инициализируйте обучаемые признаки запросов и пространственные опорные точки (ограничиваясь основной группой на этапе вывода для повышения эффективности).
4. Проекция базовых опорных точек по всему батчу, их уточнение с помощью предсказанных корректировок координат (перенос внимания на обнаруженные расположения объектов перед декодированием) и расширение признаков целевых запросов до размеров батча.
5. Передайте уточненные запросы и обновленные опорные точки в декодер трансформера, чтобы агрегировать детальный пространственный контекст из многомасштабных признаков.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **init_reference_points** (`torch.Tensor` формы  `(batch_size, num_queries, 4)`) -- Начальные опорные точки, передаваемые через декодер Transformer.
- **intermediate_hidden_states** (`torch.Tensor` формы `(batch_size, config.decoder_layers, num_queries, d_model)`) -- Стек промежуточных скрытых состояний (выход каждого слоя декодера).
- **intermediate_reference_points** (`torch.Tensor` формы `(batch_size, config.decoder_layers, num_queries, 4)`) -- Стек промежуточных опорных точек (опорные точки каждого слоя декодера).
- **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`) -- Логиты координат предсказанных ограничивающих прямоугольников на первом этапе.
- **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** (`list` из `torch.Tensor` формы `(batch_size, config.num_channels, config.image_size, config.image_size)`) -- Признаки из backbone.

Примеры:

```python
>>> 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[[transformers.RfDetrForObjectDetection]]

#### transformers.RfDetrForObjectDetection[[transformers.RfDetrForObjectDetection]]

```python
transformers.RfDetrForObjectDetection(config: RfDetrConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1678)

**Параметры:**

config ([RfDetrConfig](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель LW DETR (состоящая из backbone и decoder Transformer) с головками для обнаружения объектов, предназначенная для таких задач, как обнаружение объектов COCO.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.RfDetrForObjectDetection.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1692)

**Параметры:**

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательно*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [RfDetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrImageProcessor). Подробности см. в [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) (`processor_class` использует [RfDetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrImageProcessor) для обработки изображений).

pixel_mask (`torch.LongTensor` формы `(batch_size, height, width)`, *необязательно*) : Маска для исключения значений пикселей отступов из внимания. Значения маски выбираются из `[0, 1]`:  - 1 для реальных пикселей (т. е. **не замаскированных**), - 0 для пикселей отступов (т. е. **замаскированных**).  [Что такое маски внимания?](../glossary#attention-mask)

labels (`list[Dict]` длины `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь бипартитного сопоставления. Список словарей, каждый из которых содержит как минимум следующие два ключа: 'class_labels' и 'boxes' (соответственно, метки классов и ограничивающие рамки изображения в батче). Сами метки классов должны представлять собой `torch.LongTensor` длины `(number of bounding boxes in the image,)`, а рамки — `torch.Tensor` формы `(number of bounding boxes in the image, 4)`.

**Возвращает:** `RfDetrObjectDetectionOutput` или `tuple(torch.Tensor)`

Объект `RfDetrObjectDetectionOutput` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([RfDetrConfig](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrConfig)) и входных данных.

Прямой проход выполняется следующим образом:

1. Обработайте визуальный вход с помощью базовой модели RF-DETR, чтобы получить последнее скрытое состояние трансформера и финальную последовательность опорных точек.
2. Первый этап: генерация логитов классификации из эмбеддингов объектных запросов, предложенных кодировщиком.
3. Второй этап: предсказание финальных меток классификации и уточненных ограничивающих прямоугольников с использованием последнего скрытого состояния декодера и наиболее актуальных опорных точек.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если предоставлены `labels`)) -- Суммарная потеря, представляющая собой линейную комбинацию отрицательного логарифма правдоподобия (кросс-энтропии) для предсказания класса и потери для ограничивающих прямоугольников. Последняя определяется как линейная комбинация L1-потери и обобщенной масштабно-инвариантной потери IoU.
- **loss_dict** (`Dict`, *необязательный*) -- Словарь, содержащий отдельные значения потерь. Полезно для ведения журнала.
- **logits** (`torch.Tensor` формы `(batch_size, num_queries, num_classes + 1)`) -- Логиты классификации (включая no-object) для всех запросов.
- **pred_boxes** (`torch.Tensor` формы `(batch_size, num_queries, 4)`) -- Нормализованные координаты границ для всех запросов, представленные в виде (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** (`torch.Tensor` формы  `(batch_size, num_queries, 4)`) -- Начальные опорные точки, передаваемые через декодер Transformer.
- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **intermediate_hidden_states** (`torch.Tensor` формы `(batch_size, config.decoder_layers, num_queries, d_model)`) -- Стек промежуточных скрытых состояний (выход каждого слоя декодера).
- **intermediate_reference_points** (`torch.Tensor` формы `(batch_size, config.decoder_layers, num_queries, 4)`) -- Стек промежуточных опорных точек (опорные точки каждого слоя декодера).
- **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`) -- Логиты координат предсказанных ограничивающих прямоугольников на первом этапе.
- **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** (`list` из `torch.Tensor` формы `(batch_size, config.num_channels, config.image_size, config.image_size)`) -- Признаки из backbone.

Примеры:

```python
>>> 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[[transformers.RfDetrForInstanceSegmentation]]

#### transformers.RfDetrForInstanceSegmentation[[transformers.RfDetrForInstanceSegmentation]]

```python
transformers.RfDetrForInstanceSegmentation(config: RfDetrConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L1938)

#### forward[[transformers.RfDetrForInstanceSegmentation.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L2020)

**Параметры:**

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательно*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [RfDetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrImageProcessor). Подробности см. в [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) (`processor_class` использует [RfDetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrImageProcessor) для обработки изображений).

pixel_mask (`torch.LongTensor` формы `(batch_size, height, width)`, *необязательно*) : Маска для исключения значений пикселей отступов из внимания. Значения маски выбираются из `[0, 1]`:  - 1 для реальных пикселей (т. е. **не замаскированных**), - 0 для пикселей отступов (т. е. **замаскированных**).  [Что такое маски внимания?](../glossary#attention-mask)

labels (`list[Dict]` длины `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь бипартитного сопоставления. Список словарей, каждый из которых содержит как минимум следующие два ключа: 'class_labels' и 'boxes' (соответственно, метки классов и ограничивающие рамки изображения в батче). Сами метки классов должны представлять собой `torch.LongTensor` длины `(number of bounding boxes in the image,)`, а рамки — `torch.Tensor` формы `(number of bounding boxes in the image, 4)`.

**Возвращаемое значение:**

`dict[str, torch.Tensor]`

Прямой проход модели RF-DETR для сегментации объектов. Конвейер выполняется следующим образом:

1. Обработайте визуальный вход с помощью базовой модели RF-DETR, чтобы получить многомасштабные пространственные признаки, эмбеддинги запросов и историю их трансформации.
2. Сгенерировать логиты классификации и начальные маски сегментации из эмбеддингов запросов объектов, предложенных кодировщиком (первый этап).
3. Предскажите финальные метки классификации и уточнённые ограничивающие прямоугольники, используя последнее скрытое состояние декодера (второй этап).
4. Передайте пространственные признаки высокого разрешения и скрытые состояния запросов через сегментационную голову, чтобы получить финальные детальные маски инстансов.

## RfDetrDinov2Backbone[[transformers.RfDetrDinov2Backbone]]

#### transformers.RfDetrDinov2Backbone[[transformers.RfDetrDinov2Backbone]]

```python
transformers.RfDetrDinov2Backbone(config: RfDetrDinov2Config)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L473)

**Параметры:**

config ([RfDetrDinov2Config](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrDinov2Config)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Backbone RfDetrDinov2, предназначенный для использования в таких фреймворках, как DETR и MaskFormer.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.RfDetrDinov2Backbone.forward]]

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rf_detr/modeling_rf_detr.py#L482)

**Параметры:**

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [RfDetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrImageProcessor). Подробности см. в [RfDetrImageProcessor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) (`processor_class` использует [RfDetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrImageProcessor) для обработки изображений).

**Возвращает:** `BackboneOutput` или `tuple(torch.Tensor)`

Объект `BackboneOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([RfDetrConfig](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrConfig)) и входных данных.

Метод forward класса [RfDetrDinov2Backbone](/docs/transformers/v5.23.0/ru/model_doc/rf_detr#transformers.RfDetrDinov2Backbone) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **feature_maps** (`tuple(torch.Tensor)` формы `(batch_size, num_channels, height, width)`) -- Карты признаков на каждом этапе.
- **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Примеры:

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

