# DAB-DETR

## Обзор

Модель DAB-DETR была предложена в статье [DAB-DETR: Dynamic Anchor Boxes are Better Queries for DETR](https://huggingface.co/papers/2201.12329) авторами Shilong Liu, Feng Li, Hao Zhang, Xiao Yang, Xianbiao Qi, Hang Su, Jun Zhu, Lei Zhang. DAB-DETR представляет собой улучшенный вариант Conditional DETR. Она использует динамически обновляемые якорные рамки для предоставления как опорной точки запроса (x, y), так и опорного размера якоря (w, h), что улучшает вычисления кросс-внимания. Этот новый подход достигает 45,7% AP при обучении в течение 50 эпох с использованием одной модели ResNet-50 в качестве базовой архитектуры.

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/dab_detr_convergence_plot.png"
alt="drawing" width="600"/>

Аннотация из статьи следующая:

*В данной статье мы предлагаем новую формулировку запросов с использованием динамических якорных прямоугольников для DETR (DEtection TRansformer) и даём более глубокое понимание роли запросов в DETR. Эта новая формулировка напрямую использует координаты прямоугольников в качестве запросов в декодерах Transformer и динамически обновляет их слой за слоем. Использование координат прямоугольников не только позволяет применять явные позиционные априорные данные для улучшения сходства между запросами и признаками и устранения проблемы медленной сходимости обучения в DETR, но и даёт возможность модулировать карту позиционного внимания с использованием информации о ширине и высоте прямоугольника. Такой дизайн делает очевидным, что запросы в DETR могут быть реализованы как выполнение мягкого ROI-пулинга слой за слоем в каскадном режиме. В результате это обеспечивает наилучшие показатели на бенчмарке MS-COCO среди моделей обнаружения, подобных DETR, при одинаковых условиях, например, AP 45,7% с использованием ResNet50-DC5 в качестве базовой модели, обученной за 50 эпох. Мы также провели обширные эксперименты для подтверждения нашего анализа и проверки эффективности наших методов.*

Эта модель была добавлена пользователем [davidhajdu](https://huggingface.co/davidhajdu). Исходный код можно найти [здесь](https://github.com/IDEA-Research/DAB-DETR).

## Как начать работу с моделью

Используйте код ниже, чтобы начать работу с моделью.

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

from transformers import AutoImageProcessor, AutoModelForObjectDetection

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

image_processor = AutoImageProcessor.from_pretrained("IDEA-Research/dab-detr-resnet-50")
model = AutoModelForObjectDetection.from_pretrained("IDEA-Research/dab-detr-resnet-50", 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.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}")
```

Это должно вывести

```text
cat: 0.87 [14.7, 49.39, 320.52, 469.28]
remote: 0.86 [41.08, 72.37, 173.39, 117.2]
cat: 0.86 [344.45, 19.43, 639.85, 367.86]
remote: 0.61 [334.27, 75.93, 367.92, 188.81]
couch: 0.59 [-0.04, 1.34, 639.9, 477.09]
```

Существует ещё три способа инициализации модели DAB-DETR (в зависимости от ваших предпочтений):

Вариант 1: Инициализация DAB-DETR с предобученными весами для всей модели

```python
from transformers import DabDetrForObjectDetection

model = DabDetrForObjectDetection.from_pretrained("IDEA-Research/dab-detr-resnet-50", device_map="auto")
```

Вариант 2: Инициализация DAB-DETR со случайными весами для Transformer, но с предобученными весами для backbone

```python
from transformers import DabDetrConfig, DabDetrForObjectDetection

config = DabDetrConfig()
model = DabDetrForObjectDetection(config)
```

Вариант 3: Инициализация DAB-DETR со случайными весами для backbone + Transformer

```py
config = DabDetrConfig()
model = DabDetrForObjectDetection(config)
```

## DabDetrConfig[[transformers.DabDetrConfig]]

#### transformers.DabDetrConfig[[transformers.DabDetrConfig]]

```python
transformers.DabDetrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_queries: int = 300, encoder_layers: int = 6, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 8, activation_function: str = 'prelu', hidden_size: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, init_xavier_std: float = 1.0, auxiliary_loss: bool = False, dilation: bool = False, class_cost: int = 2, bbox_cost: int = 5, giou_cost: int = 2, cls_loss_coefficient: int = 2, bbox_loss_coefficient: int = 5, giou_loss_coefficient: int = 2, focal_alpha: float = 0.25, temperature_height: int = 20, temperature_width: int = 20, query_dim: int = 4, random_refpoints_xy: bool = False, keep_query_pos: bool = False, num_patterns: int = 0, normalize_before: bool = False, sine_position_embedding_scale: float | None = None, initializer_bias_prior_prob: float | None = None, tie_word_embeddings: bool = True)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dab_detr/configuration_dab_detr.py#L25)

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

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

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Конфигурация базовой модели.

num_queries (`int`, *optional*, по умолчанию 300) : Количество запросов объектов, то есть слотов для обнаружения. Это максимальное число объектов, которые [DabDetrModel](/docs/transformers/main/ru/model_doc/dab-detr#transformers.DabDetrModel) может обнаружить на одном изображении. Для COCO мы рекомендуем 100 запросов.

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

encoder_ffn_dim (`int`, *optional*, по умолчанию `2048`) : Размерность «промежуточного» (часто называемого feed-forward) слоя в энкодере.

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

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

decoder_ffn_dim (`int`, *необязательный*, по умолчанию `2048`) : Размерность «промежуточного» (часто называемого feed-forward) слоя в декодере.

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

activation_function (`str`, *optional*, по умолчанию `prelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

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

dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля для всех слоёв dropout.

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

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

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

init_xavier_std (`float`, *необязательный*, по умолчанию `1.0`) : Коэффициент масштабирования, используемый для инициализации кросс-внимания по методу Ксавье.

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

dilation (`bool`, *необязательный*, по умолчанию `False`) : Заменять ли stride на dilation в последнем свёрточном блоке (DC5). Поддерживается только при `use_timm_backbone` = `True`.

class_cost (`int`, *optional*, по умолчанию `2`) : Относительный вес ошибки классификации в стоимости венгерского сопоставления.

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

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

cls_loss_coefficient (`int`, *optional*, по умолчанию `2`) : Относительный вес функции потерь классификации в функции потерь паноптической сегментации.

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

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

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

temperature_height (`int`, *optional*, по умолчанию 20) : Параметр Temperature для настройки плоскостности позиционного внимания (HEIGHT)

temperature_width (`int`, *optional*, по умолчанию 20) : Параметр Temperature для настройки плоскостности позиционного внимания (WIDTH)

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

random_refpoints_xy (`bool`, *необязательный*, по умолчанию `False`) : Фиксировать ли координаты x и y якорных прямоугольников с помощью случайной инициализации.

keep_query_pos (`bool`, *необязательный*, по умолчанию `False`) : Служит для определения, следует ли конкатенировать спроецированное позиционное вложение из object query с исходным query (key) в каждом слое декодера.

num_patterns (`int`, *необязательный*, по умолчанию 0) : Количество встраиваний паттернов.

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

sine_position_embedding_scale (`float`, *необязательный*, по умолчанию 'None') : Коэффициент масштабирования, применяемый к нормализованным позиционным кодировкам.

initializer_bias_prior_prob (`float`, *optional*) : Априорная вероятность, используемая инициализатором смещений для инициализации смещений `enc_score_head` и `class_embed`. Если `None`, `prior_prob` вычисляется как `prior_prob = 1 / (num_labels + 1)` при инициализации весов модели.

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

Это класс конфигурации для хранения настроек модели Dab DetrModel. Он используется для создания модели Dab Detr в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [IDEA-Research/dab-detr-resnet-50](https://huggingface.co/IDEA-Research/dab-detr-resnet-50)

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

Примеры:

```python
>>> from transformers import DabDetrConfig, DabDetrModel

>>> # Initializing a DAB-DETR IDEA-Research/dab-detr-resnet-50 style configuration
>>> configuration = DabDetrConfig()

>>> # Initializing a model (with random weights) from the IDEA-Research/dab-detr-resnet-50 style configuration
>>> model = DabDetrModel(configuration)

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

## DabDetrModel[[transformers.DabDetrModel]]

#### transformers.DabDetrModel[[transformers.DabDetrModel]]

```python
transformers.DabDetrModel(config: DabDetrConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dab_detr/modeling_dab_detr.py#L1144)

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

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

Модель DAB-DETR без дополнительных модулей (состоящая из базовой сети и трансформера с кодировщиком-декодировщиком), на выходе которой формируются необработанные скрытые состояния, промежуточные скрытые состояния, опорные точки и выходные координаты без какого-либо специализированного модуля на вершине.

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

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

#### forward[[transformers.DabDetrModel.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dab_detr/modeling_dab_detr.py#L1196)

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

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` (`processor_class` использует `image_processor_class` для обработки изображений).

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

decoder_attention_mask (`torch.Tensor` формы `(batch_size, num_queries)`, *необязательный*) : По умолчанию не используется. Может применяться для маскирования запросов объектов.

encoder_outputs (`torch.Tensor`, *необязательный*) : Кортеж, состоящий из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи сглаженной карты признаков (выход backbone + проекционного слоя), можно напрямую передать сглаженное представление изображения.

decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, num_queries, hidden_size)`, *необязательно*) : По желанию, вместо инициализации запросов тензором нулей, можно передать встроенное представление напрямую.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

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

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

Метод forward модели [DabDetrModel](/docs/transformers/main/ru/model_doc/dab-detr#transformers.DabDetrModel) переопределяет специальный метод `__call__`.

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

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя декодера модели.

  Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`.
- **past_key_values** (`EncoderDecoderCache`, *необязательный*, возвращается при передаче `use_cache=True` или при `config.use_cache=True`) -- это экземпляр [EncoderDecoderCache](/docs/transformers/main/ru/internal/generation_utils#transformers.EncoderDecoderCache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния декодера на выходе каждого слоя, а также необязательные выходные значения начального эмбеддинга.
- **decoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания декодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания.
- **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния энкодера на выходе каждого слоя, а также необязательные выходные значения начального эмбеддинга.
- **encoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **intermediate_hidden_states** (`torch.Tensor` формы `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *необязательный*, возвращается при `config.auxiliary_loss=True`) -- Промежуточные активации декодера, то есть выход каждого слоя декодера, прошедший через layernorm.
- **reference_points** (`torch.Tensor` формы `(config.decoder_layers, batch_size, num_queries, 2 (anchor points))`) -- Точки отсчёта (точки отсчёта каждого слоя декодера).

Примеры:

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("IDEA-Research/dab-detr-resnet-50")
>>> model = AutoModel.from_pretrained("IDEA-Research/dab-detr-resnet-50")

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

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

>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]
```

## DabDetrForObjectDetection[[transformers.DabDetrForObjectDetection]]

#### transformers.DabDetrForObjectDetection[[transformers.DabDetrForObjectDetection]]

```python
transformers.DabDetrForObjectDetection(config: DabDetrConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dab_detr/modeling_dab_detr.py#L1416)

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

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

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

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

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

#### forward[[transformers.DabDetrForObjectDetection.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dab_detr/modeling_dab_detr.py#L1445)

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

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` (`processor_class` использует `image_processor_class` для обработки изображений).

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

decoder_attention_mask (`torch.Tensor` формы `(batch_size, num_queries)`, *необязательный*) : По умолчанию не используется. Может применяться для маскирования запросов объектов.

encoder_outputs (`torch.Tensor`, *необязательный*) : Кортеж, состоящий из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи сглаженной карты признаков (выход backbone + проекционного слоя), можно напрямую передать сглаженное представление изображения.

decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, num_queries, hidden_size)`, *необязательно*) : По желанию, вместо инициализации запросов тензором нулей, можно передать встроенное представление напрямую.

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

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

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

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

Метод forward класса [DabDetrForObjectDetection](/docs/transformers/main/ru/model_doc/dab-detr#transformers.DabDetrForObjectDetection) переопределяет специальный метод `__call__`.

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

- **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] относительно размера каждого отдельного изображения в батче (игнорируя возможное выравнивание). Для получения ненормализованных границ используйте `~DabDetrImageProcessor.post_process_object_detection`.
- **auxiliary_outputs** (`list[Dict]`, *необязательный*) -- Необязательный параметр, возвращается только при активации вспомогательных потерь (т. е. когда `config.auxiliary_loss` установлен в `True`) и при наличии меток. Это список словарей, содержащих два указанных выше ключа (`logits` и `pred_boxes`) для каждого слоя декодера.
- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя декодера модели.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния декодера на выходе каждого слоя, а также выходные значения начального слоя встраивания.
- **decoder_attentions** (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания декодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **cross_attentions** (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания.
- **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния кодировщика на выходе каждого слоя, а также выходные значения начального слоя встраиваний.
- **encoder_attentions** (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Примеры:

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("IDEA-Research/dab-detr-resnet-50")
>>> model = AutoModelForObjectDetection.from_pretrained("IDEA-Research/dab-detr-resnet-50")

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

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

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([(image.height, image.width)])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[0]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected remote with confidence 0.833 at location [38.31, 72.1, 177.63, 118.45]
Detected cat with confidence 0.831 at location [9.2, 51.38, 321.13, 469.0]
Detected cat with confidence 0.804 at location [340.3, 16.85, 642.93, 370.95]
Detected remote with confidence 0.683 at location [334.48, 73.49, 366.37, 190.01]
Detected couch with confidence 0.535 at location [0.52, 1.19, 640.35, 475.1]
```