# OmDet-Turbo

## Обзор

Модель OmDet-Turbo была предложена в статье [Real-time Transformer-based Open-Vocabulary Detection with Efficient Fusion Head](https://huggingface.co/papers/2403.06892) авторами Tiancheng Zhao, Peng Liu, Xuan He, Lu Zhang, Kyusong Lee. OmDet-Turbo включает компоненты из RT-DETR и вводит быстрый модуль мультимодального слияния, что позволяет достигать возможностей детектирования объектов в открытом словаре в реальном времени при сохранении высокой точности. Базовая модель демонстрирует производительность до 100.2 FPS и 53.4 AP на COCO zero-shot.

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

*Детекторы объектов на основе трансформеров, работающие «от входа до выхода» (DETR), продемонстрировали выдающуюся производительность как в задачах детектирования объектов с фиксированным набором классов, так и в задачах детектирования объектов с открытым словарем (OVD) благодаря интеграции языковых модальностей. Однако высокие вычислительные требования этих моделей препятствуют их практическому применению в сценариях детектирования объектов в реальном времени (OD). В данной статье мы подробно рассматриваем ограничения двух ведущих моделей в бенчмарке OVDEval — OmDet и Grounding-DINO — и представляем OmDet-Turbo. Эта новая модель OVD в реальном времени на основе трансформеров включает инновационный модуль Efficient Fusion Head (EFH), разработанный для устранения узких мест, наблюдаемых в OmDet и Grounding-DINO. Примечательно, что OmDet-Turbo-Base достигает 100,2 кадров в секунду (FPS) при использовании TensorRT и техник кэширования языковых признаков. Примечательно, что в сценариях zero-shot на наборах данных COCO и LVIS OmDet-Turbo достигает уровня производительности, практически сопоставимого с текущими лучшими надзорными моделями. Кроме того, он устанавливает новые рекорды производительности в бенчмарках ODinW и OVDEval, показывая AP 30,1 и NMS-AP 26,86 соответственно. Практичность OmDet-Turbo для промышленных приложений подчеркивается его выдающейся производительностью на эталонных наборах данных и превосходной скоростью инференса, что делает его привлекательным выбором для задач детектирования объектов в реальном времени.*

 Обзор архитектуры OmDet-Turbo. Взято из оригинальной статьи.

Эта модель была добавлена пользователем [yonigozlan](https://huggingface.co/yonigozlan). Исходный код можно найти [здесь](https://github.com/om-ai-lab/OmDet).

## Советы по использованию

Одной из уникальных особенностей OmDet-Turbo по сравнению с другими моделями zero-shot обнаружения объектов, такими как [Grounding DINO](grounding-dino), является структура с разделёнными эмбеддингами классов и промптов, которая позволяет кэшировать текстовые эмбеддинги. Это означает, что модели в качестве входных данных необходимы и классы, и задача, где classes — это список объектов, которые мы хотим обнаружить, а task — это привязанный текст, используемый для управления обнаружением объектов произвольного словаря. Такой подход ограничивает область применения обнаружения объектов произвольного словаря и ускоряет процесс декодирования.

[OmDetTurboProcessor](/docs/transformers/main/ru/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) используется для подготовки тройки «классы, задача, изображение». Входной параметр задачи является необязательным; если он не указан, по умолчанию используется значение `"Detect [class1], [class2], [class3], ..."`. Для обработки результатов модели можно использовать функцию `post_process_grounded_object_detection` из [OmDetTurboProcessor](/docs/transformers/main/ru/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Примечательно, что эта функция принимает на вход список классов, поскольку, в отличие от других zero-shot моделей обнаружения объектов, разделение эмбеддингов классов и задач означает, что на этапе постобработки не требуется декодирование предсказанных эмбеддингов классов: предсказанные классы можно напрямую сопоставить с переданными на вход.

## Пример использования

### Инференс для одного изображения

Вот как загрузить модель и подготовить входные данные для выполнения детекции объектов в режиме zero-shot на одном изображении:

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

from transformers import AutoProcessor, OmDetTurboForObjectDetection

processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf", device_map="auto")

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
text_labels = ["cat", "remote"]
inputs = processor(image, text=text_labels, return_tensors="pt").to(model.device)

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

# convert outputs (bounding boxes and class logits)
results = processor.post_process_grounded_object_detection(
    outputs,
    target_sizes=[(image.height, image.width)],
    text_labels=text_labels,
    threshold=0.3,
    nms_threshold=0.3,
)
result = results[0]
boxes, scores, text_labels = result["boxes"], result["scores"], result["text_labels"]
for box, score, text_label in zip(boxes, scores, text_labels):
    box = [round(i, 2) for i in box.tolist()]
    print(f"Detected {text_label} with confidence {round(score.item(), 3)} at location {box}")
Detected remote with confidence 0.768 at location [39.89, 70.35, 176.74, 118.04]
Detected cat with confidence 0.72 at location [11.6, 54.19, 314.8, 473.95]
Detected remote with confidence 0.563 at location [333.38, 75.77, 370.7, 187.03]
Detected cat with confidence 0.552 at location [345.15, 23.95, 639.75, 371.67]
```

### Инференс с несколькими изображениями

OmDet-Turbo поддерживает пакетный вывод для нескольких изображений, при этом в одном пакете могут использоваться разные текстовые подсказки и классы:

```python
import torch
import requests
from io import BytesIO
from PIL import Image
from transformers import AutoProcessor, OmDetTurboForObjectDetection

processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf", device_map="auto")

url1 = "http://images.cocodataset.org/val2017/000000039769.jpg"
image1 = Image.open(BytesIO(requests.get(url1).content)).convert("RGB")
text_labels1 = ["cat", "remote"]
task1 = "Detect {}.".format(", ".join(text_labels1))

url2 = "http://images.cocodataset.org/train2017/000000257813.jpg"
image2 = Image.open(BytesIO(requests.get(url2).content)).convert("RGB")
text_labels2 = ["boat"]
task2 = "Detect everything that looks like a boat."

url3 = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"
image3 = Image.open(BytesIO(requests.get(url3).content)).convert("RGB")
text_labels3 = ["statue", "trees"]
task3 = "Focus on the foreground, detect statue and trees."

inputs = processor(
    images=[image1, image2, image3],
    text=[text_labels1, text_labels2, text_labels3],
    task=[task1, task2, task3],
    return_tensors="pt",
)

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

# convert outputs (bounding boxes and class logits)
results = processor.post_process_grounded_object_detection(
    outputs,
    text_labels=[text_labels1, text_labels2, text_labels3],
    target_sizes=[(image.height, image.width) for image in [image1, image2, image3]],
    threshold=0.2,
    nms_threshold=0.3,
)

for i, result in enumerate(results):
    for score, text_label, box in zip(
        result["scores"], result["text_labels"], result["boxes"]
    ):
        box = [round(i, 1) for i in box.tolist()]
        print(
            f"Detected {text_label} with confidence "
            f"{round(score.item(), 2)} at location {box} in image {i}"
        )
Detected remote with confidence 0.77 at location [39.9, 70.4, 176.7, 118.0] in image 0
Detected cat with confidence 0.72 at location [11.6, 54.2, 314.8, 474.0] in image 0
Detected remote with confidence 0.56 at location [333.4, 75.8, 370.7, 187.0] in image 0
Detected cat with confidence 0.55 at location [345.2, 24.0, 639.8, 371.7] in image 0
Detected boat with confidence 0.32 at location [146.9, 219.8, 209.6, 250.7] in image 1
Detected boat with confidence 0.3 at location [319.1, 223.2, 403.2, 238.4] in image 1
Detected boat with confidence 0.27 at location [37.7, 220.3, 84.0, 235.9] in image 1
Detected boat with confidence 0.22 at location [407.9, 207.0, 441.7, 220.2] in image 1
Detected statue with confidence 0.73 at location [544.7, 210.2, 651.9, 502.8] in image 2
Detected trees with confidence 0.25 at location [3.9, 584.3, 391.4, 785.6] in image 2
Detected trees with confidence 0.25 at location [1.4, 621.2, 118.2, 787.8] in image 2
Detected statue with confidence 0.2 at location [428.1, 205.5, 767.3, 759.5] in image 2

```

## OmDetTurboConfig[[transformers.OmDetTurboConfig]]

#### transformers.OmDetTurboConfig[[transformers.OmDetTurboConfig]]

```python
transformers.OmDetTurboConfig(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, apply_layernorm_after_vision_backbone: bool = True, image_size: int | list[int] | tuple[int, int] = 640, disable_custom_kernels: bool = False, layer_norm_eps: float = 1e-05, batch_norm_eps: float = 1e-05, init_std: float = 0.02, text_projection_in_dim: int = 512, text_projection_out_dim: int = 512, task_encoder_hidden_dim: int = 1024, class_embed_dim: int = 512, class_distance_type: typing.Literal['cosine', 'dot'] = 'cosine', num_queries: int = 900, csp_activation: str = 'silu', conv_norm_activation: str = 'gelu', encoder_feedforward_activation: str = 'relu', encoder_feedforward_dropout: float | int = 0.0, encoder_dropout: float | int = 0.0, hidden_expansion: int = 1, encoder_hidden_dim: int = 256, vision_features_channels: list[int] | tuple[int, ...] = (256, 256, 256), encoder_in_channels: list[int] | tuple[int, ...] = (192, 384, 768), encoder_projection_indices: list[int] | tuple[int, ...] = (2,), encoder_attention_heads: int = 8, encoder_dim_feedforward: int = 2048, encoder_layers: int = 1, positional_encoding_temperature: int = 10000, num_feature_levels: int = 3, decoder_hidden_dim: int = 256, decoder_num_heads: int = 8, decoder_num_layers: int = 6, decoder_activation: str = 'relu', decoder_dim_feedforward: int = 2048, decoder_num_points: int = 4, decoder_dropout: float | int = 0.0, eval_size: int | None = None, learn_initial_query: bool = False, cache_size: int = 100)
```

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

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

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

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь текстового бэкбона.

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

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

image_size (`Union[int, list[int], tuple[int, int]]`, *необязательный*, по умолчанию `640`) : Размер (разрешение) каждого изображения.

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

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

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

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

text_projection_in_dim (`int`, *optional*, по умолчанию 512) : Входное измерение для проекции текста.

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

task_encoder_hidden_dim (`int`, *optional*, по умолчанию 1024) : Размерность полносвязного слоя для кодировщика задачи.

class_embed_dim (`int`, *optional*, по умолчанию 512) : Размерность эмбеддингов классов.

class_distance_type (`str`, *необязательный*, по умолчанию `"cosine"`) : Тип расстояния для сравнения предсказанных классов с проекциями эмбеддингов классов. Может быть `"cosine"` или `"dot"`.

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

csp_activation (`str`, *необязательный*, по умолчанию `"silu"`) : Функция активации сетей Cross Stage Partial (CSP) в кодере.

conv_norm_activation (`str`, *необязательный*, по умолчанию `"gelu"`) : Функция активации для слоёв ConvNormLayer в кодировщике.

encoder_feedforward_activation (`str`, *необязательный*, по умолчанию `"relu"`) : Функция активации для полносвязной сети энкодера.

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

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

hidden_expansion (`int`, *optional*, по умолчанию 1) : Скрытое расширение CSP-сетей в кодировщике.

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

vision_features_channels (`tuple(int)`, *optional*, по умолчанию `[256, 256, 256]`) : Количество каналов проекционных визуальных признаков, используемых в качестве входных данных для декодера.

encoder_in_channels (`List(int)`, *необязательный*, по умолчанию `[192, 384, 768]`) : Входные каналы для кодировщика.

encoder_projection_indices (`List(int)`, *необязательный*, по умолчанию `[2]`) : Индексы входных признаков, проецируемых каждым слоем.

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

encoder_dim_feedforward (`int`, *optional*, по умолчанию 2048) : Размерность полносвязного слоя для кодировщика.

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

positional_encoding_temperature (`int`, *optional*, по умолчанию 10000) : Температура позиционного кодирования в энкодере.

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

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

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

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

decoder_activation (`str`, *необязательный*, по умолчанию `"relu"`) : Функция активации для декодера.

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

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

decoder_dropout (`float`, *необязательный*, по умолчанию 0.0) : Коэффициент dropout для декодера.

eval_size (`tuple[int, int]`, *необязательный*) : Высота и ширина, используемые для вычисления эффективной высоты и ширины позиционных эмбеддингов с учётом шага (см. RTDetr).

learn_initial_query (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли обучать начальный запрос.

cache_size (`int`, *optional*, по умолчанию 100) : Размер кэша для классов и промптов.

Это класс конфигурации для хранения настроек модели Omdet TurboModel. Он используется для создания модели Omdet Turbo в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [omlab/omdet-turbo-swin-tiny-hf](https://huggingface.co/omlab/omdet-turbo-swin-tiny-hf)

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

Примеры:

```python
>>> from transformers import OmDetTurboConfig, OmDetTurboForObjectDetection

>>> # Initializing a OmDet-Turbo omlab/omdet-turbo-swin-tiny-hf style configuration
>>> configuration = OmDetTurboConfig()

>>> # Initializing a model (with random weights) from the omlab/omdet-turbo-swin-tiny-hf style configuration
>>> model = OmDetTurboForObjectDetection(configuration)

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

## OmDetTurboProcessor[[transformers.OmDetTurboProcessor]]

#### transformers.OmDetTurboProcessor[[transformers.OmDetTurboProcessor]]

```python
transformers.OmDetTurboProcessor(image_processor, tokenizer)
```

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

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

image_processor (`DetrImageProcessor`) : процессор изображений является обязательным входным параметром.

tokenizer (`CLIPTokenizer`) : Токенизатор является обязательным входным параметром.

Создаёт OmDetTurboProcessor, который объединяет процессор изображений и токенизатор в единый процессор.

[OmDetTurboProcessor](/docs/transformers/main/ru/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) предоставляет все возможности [DetrImageProcessor](/docs/transformers/main/ru/model_doc/detr#transformers.DetrImageProcessor) и [CLIPTokenizer](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPTokenizer). Подробнее см. в [~DetrImageProcessor](/docs/transformers/main/ru/model_doc/detr#transformers.DetrImageProcessor) и [~CLIPTokenizer](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPTokenizer).

#### __call__[[transformers.OmDetTurboProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: list[str] | list[list[str]] | None = None, **kwargs: *<class 'transformers.models.omdet_turbo.processing_omdet_turbo.OmDetTurboProcessorKwargs'>)
```

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

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

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

text (`Union[list[str], list[list[str]]]`, *необязательный*) : Последовательность или батч последовательностей для кодирования. Каждая последовательность может быть строкой или списком строк (предтокенизированная строка). Если вы передаёте предтокенизированный вход, установите `is_split_into_words=True`, чтобы избежать неоднозначности с батчированными входами.

task (`str`, *kwargs*, `list[str]`, `TextInput` или `PreTokenizedInput`, *optional*) : Описание(я) задачи детектирования для кодирования. Если не указано, описание задачи по умолчанию генерируется на основе входных данных `text` (например, "Detect {text}."). Может быть одной строкой, списком строк (по одной на изображение) или предтокенизированным входом. Описание задачи направляет модель в определении объектов, которые необходимо обнаружить на изображениях.

return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict.

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

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

#### post_process_grounded_object_detection[[transformers.OmDetTurboProcessor.post_process_grounded_object_detection]]

```python
post_process_grounded_object_detection(outputs: OmDetTurboObjectDetectionOutput, text_labels: list[str] | list[list[str]] | None = None, threshold: float = 0.3, nms_threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None, max_num_det: int | None = None)
```

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

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

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

text_labels (Union[list[str], list[list[str]]], *optional*) : Имена входных классов. Если не указаны, `text_labels` будет установлено в `None` в `outputs`.

threshold (float, по умолчанию 0.3) : Возвращать только обнаружения с оценкой уверенности, превышающей этот порог.

nms_threshold (float, по умолчанию 0.5) : Порог для подавления не-максимумов (non-maximum suppression) в рамках обнаружения объектов. Значение в диапазоне [0, 1].

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

max_num_det (`int`, *необязательный*) : Максимальное количество обнаружений, которые нужно вернуть.

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

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

Преобразует необработанный вывод [OmDetTurboForObjectDetection](/docs/transformers/main/ru/model_doc/omdet-turbo#transformers.OmDetTurboForObjectDetection) в итоговые ограничивающие прямоугольники в формате (top_left_x, top_left_y, bottom_right_x, bottom_right_y) и получает соответствующий текстовый класс.

## OmDetTurboForObjectDetection[[transformers.OmDetTurboForObjectDetection]]

#### transformers.OmDetTurboForObjectDetection[[transformers.OmDetTurboForObjectDetection]]

```python
transformers.OmDetTurboForObjectDetection(config: OmDetTurboConfig)
```

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

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

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

Модель OmDetTurbo (состоящая из визуального и текстового бэкбона, а также архитектуры «энкодер-декодер»), выводящая ограничивающие рамки и оценки классов для таких задач, как обнаружение объектов COCO.

Эта модель наследуется от [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.OmDetTurboForObjectDetection.forward]]

```python
forward(pixel_values: Tensor, classes_input_ids: LongTensor, classes_attention_mask: LongTensor, tasks_input_ids: LongTensor, tasks_attention_mask: LongTensor, classes_structure: LongTensor, labels: typing.Optional[torch.LongTensor] = 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/omdet_turbo/modeling_omdet_turbo.py#L1494)

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

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

classes_input_ids (`torch.LongTensor` формы `(total_classes (>= batch_size), sequence_length)`) : Индексы токенов последовательности входных классов в словаре языковой модели. Для каждой задачи можно указать несколько классов, поэтому токенизированные классы разворачиваются в плоскую структуру, а структура классов передаётся в аргументе `classes_structure`. Индексы можно получить с помощью [OmDetTurboProcessor](/docs/transformers/main/ru/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Подробности см. в [OmDetTurboProcessor.__call__()](/docs/transformers/main/ru/model_doc/omdet-turbo#transformers.OmDetTurboProcessor.__call__). [Что такое входные ID?](../glossary#input-ids)

classes_attention_mask (`torch.BoolTensor` формы `(total_classes (>= batch_size), num_classes, sequence_length)`) : Маска внимания для классов. Это бинарная маска, указывающая, к каким токенам следует обращать внимание, а к каким — нет.

tasks_input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности задач в словаре языковой модели. Индексы можно получить с помощью [OmDetTurboProcessor](/docs/transformers/main/ru/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Подробности см. в [OmDetTurboProcessor.__call__()](/docs/transformers/main/ru/model_doc/omdet-turbo#transformers.OmDetTurboProcessor.__call__). [Что такое входные ID?](../glossary#input-ids)

tasks_attention_mask (`torch.BoolTensor` формы `(batch_size, sequence_length)`) : Маска внимания для задач. Это бинарная маска, указывающая, к каким токенам следует обращать внимание, а к каким — нет.

classes_structure (`torch.LongTensor` формы `(batch_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) вместо обычного кортежа.

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

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

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

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

- **loss** (`torch.Tensor`, *необязательный*) -- Значение функции потерь.
- **decoder_coord_logits** (`torch.Tensor` формы `(batch_size, num_queries, 4)`) -- Предсказанные координатные логиты объектов.
- **decoder_class_logits** (`torch.Tensor` формы `(batch_size, num_queries, num_classes)`) — предсказанный класс объектов.
- **init_reference_points** (`torch.Tensor` формы `(batch_size, num_queries, 4)`) -- Начальные опорные точки.
- **intermediate_reference_points** (`tuple[tuple[torch.Tensor]]`, *необязательный*) -- Промежуточные опорные точки.
- **encoder_coord_logits** (`torch.Tensor` формы `(batch_size, num_queries, 4)`) -- Предсказанные координаты объектов из энкодера.
- **encoder_class_logits** (`tuple[torch.Tensor]`, *optional*) -- Предсказанный класс объектов от энкодера.
- **encoder_extracted_states** (`torch.Tensor`, *необязательный*) -- Извлечённые состояния из Feature Pyramid Network (FPN) и Path Aggregation Network (PAN) энкодера.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *необязательный*) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также начальные выводы эмбеддингов.
- **decoder_attentions** (`tuple[tuple[torch.Tensor]]`, *необязательный*) -- Кортеж кортежей `torch.Tensor` (по одному для внимания каждого слоя) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax-функции внимания, используемые для вычисления взвешенного среднего в головах self-attention, cross-attention и multi-scale deformable attention.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *optional*) — Кортеж `torch.Tensor` (один для вывода эмбеддингов + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также начальные выводы эмбеддингов.
- **encoder_attentions** (`tuple[tuple[torch.Tensor]]`, *необязательный*) — Кортеж кортежей `torch.Tensor` (по одному для внимания каждого слоя) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax-функции внимания, используемые для вычисления взвешенного среднего в головах self-attention, cross-attention и multi-scale deformable attention.
- **classes_structure** (`torch.LongTensor`, *optional*) -- Количество запрашиваемых классов для каждого изображения.

Примеры:

```python
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image

>>> from transformers import AutoProcessor, OmDetTurboForObjectDetection

>>> processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
>>> model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> classes = ["cat", "remote"]
>>> task = "Detect {}.".format(", ".join(classes))
>>> inputs = processor(image, text=classes, task=task, return_tensors="pt")

>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits)
>>> results = processor.post_process_grounded_object_detection(
...     outputs,
...     classes=classes,
...     target_sizes=[image.size[::-1]],
...     score_threshold=0.3,
...     nms_threshold=0.3,
>>> )[0]
>>> for score, class_name, box in zip(results["scores"], results["classes"], results["boxes"]):
...     box = [round(i, 1) for i in box.tolist()]
...     print(
...         f"Detected {class_name} with confidence "
...         f"{round(score.item(), 2)} at location {box}"
...     )
Detected remote with confidence 0.76 at location [39.9, 71.3, 176.5, 117.9]
Detected cat with confidence 0.72 at location [345.1, 22.5, 639.7, 371.9]
Detected cat with confidence 0.65 at location [12.7, 53.8, 315.5, 475.3]
Detected remote with confidence 0.57 at location [333.4, 75.6, 370.7, 187.0]
```