# DETR [DETR](https://huggingface.co/papers/2005.12872) состоит из свёрточного бэкбона, за которым следует трансформер с архитектурой «энкодер-декодер», обучаемый end-to-end для обнаружения объектов. Он значительно упрощает сложность моделей, таких как Faster-R-CNN и Mask-R-CNN, которые используют, например, region proposals, процедуру non-maximum suppression и генерацию anchor. Кроме того, DETR можно естественным образом расширить для выполнения паноптической сегментации, просто добавив mask head поверх выходов декодера. Все исходные контрольные точки DETR можно найти в организации [AI at Meta](https://huggingface.co/facebook/models?search=detr). > [!TIP] > Эта модель была добавлена пользователем [nielsr](https://huggingface.co/nielsr). > > Щёлкните по моделям DETR в боковой панели справа, чтобы увидеть больше примеров применения DETR к различным задачам обнаружения объектов и сегментации. > > Установите `use_kernels=True` в [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained), чтобы заменить поддерживаемые слои на оптимизированные ядра из Hub. Подробнее см. в разделе [Загрузка ядер](../kernel_doc/loading_kernels). Приведённый ниже пример показывает, как выполнять обнаружение объектов с помощью класса [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 pipeline = pipeline( "object-detection", model="facebook/detr-resnet-50", device_map=0 ) pipeline("http://images.cocodataset.org/val2017/000000039769.jpg") ``` ```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("facebook/detr-resnet-50") model = AutoModelForObjectDetection.from_pretrained("facebook/detr-resnet-50", 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}") ``` Как работает DETR Кратко о том, как работает [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection): Сначала изображение прогоняется через предобученный свёрточный бэкбон (в статье авторы используют ResNet-50/ResNet-101). Допустим, мы также добавляем размерность батча. Это означает, что вход в бэкбон — это тензор формы `(batch_size, 3, height, width)`, при условии, что изображение имеет 3 цветовых канала (RGB). Свёрточный бэкбон выводит новую карту признаков с более низким разрешением, как правило, формы `(batch_size, 2048, height/32, width/32)`. Затем она проецируется в размерность скрытого слоя Transformer в DETR, которая по умолчанию составляет `256`, с помощью слоя `nn.Conv2D`. Таким образом, у нас получается тензор формы `(batch_size, 256, height/32, width/32).` Далее карта признаков разворачивается и транспонируется, чтобы получить тензор формы `(batch_size, seq_len, d_model)` = `(batch_size, width/32*height/32, 256)`. Таким образом, отличие от моделей NLP состоит в том, что длина последовательности здесь обычно больше, но `d_model` меньше (в NLP он обычно составляет 768 или более). Далее эти данные передаются в энкодер, который выводит `encoder_hidden_states` той же формы (их можно рассматривать как признаки изображения). Затем в декодер передаются так называемые **object queries**. Это тензор формы `(batch_size, num_queries, d_model)`, где `num_queries` обычно устанавливается в 100 и инициализируется нулями. Эти входные эмбеддинги представляют собой обучаемые позиционные кодирования, которые авторы называют object queries; аналогично энкодеру, они добавляются ко входу каждого слоя внимания. Каждый object query ищет в изображении определенный объект. Декодер обновляет эти эмбеддинги через несколько слоев self-attention и encoder-decoder attention, чтобы вывести `decoder_hidden_states` той же формы: `(batch_size, num_queries, d_model)`. Далее сверху добавляются две головы для обнаружения объектов: линейный слой для классификации каждого object query как одного из объектов или «no object», и MLP для предсказания ограничивающих прямоугольников для каждого запроса. Модель обучается с использованием **потерь двудольного сопоставления**: фактически мы сравниваем предсказанные классы и ограничивающие рамки каждого из N = 100 запросов объектов с эталонными аннотациями, дополненными до той же длины N (таким образом, если на изображении содержится только 4 объекта, то для 96 аннотаций классом будет «нет объекта», а ограничивающей рамкой — «нет рамки»). Для поиска оптимального однозначного соответствия каждого из N запросов каждому из N аннотаций используется [алгоритм венгерского сопоставления](https://en.wikipedia.org/wiki/Hungarian_algorithm). Далее для оптимизации параметров модели применяются стандартная кросс-энтропия (для классов) и линейная комбинация L1 и [потерь обобщённого IoU](https://giou.stanford.edu/) (для ограничивающих рамок). DETR можно естественным образом расширить для выполнения паноптической сегментации (которая объединяет семантическую и инстанс-сегментацию). [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) добавляет головку сегментационных масок поверх [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection). Головку масок можно обучать совместно или в двухэтапном процессе: сначала обучается модель [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection) для обнаружения ограничивающих прямоугольников вокруг «вещей» (инстансов) и «материи» (фоновых объектов, таких как деревья, дороги, небо), затем все веса замораживаются, и обучается только головка масок в течение 25 эпох. Экспериментально эти два подхода дают схожие результаты. Обратите внимание, что предсказание прямоугольников необходимо для возможности обучения, поскольку венгерское сопоставление вычисляется на основе расстояний между прямоугольниками. ## Примечания - DETR использует так называемые **object queries** для обнаружения объектов на изображении. Количество запросов определяет максимальное число объектов, которые можно обнаружить на одном изображении, и по умолчанию установлено в 100 (см. параметр `num_queries` в [DetrConfig](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrConfig)). Обратите внимание, что полезно иметь некоторый запас (в COCO авторы использовали 100, тогда как максимальное количество объектов на изображении COCO составляет ~70). - Декодер DETR обновляет эмбеддинги запросов параллельно. Это отличается от языковых моделей, таких как GPT-2, которые используют автотрессивное декодирование вместо параллельного. Поэтому маска каузального внимания не используется. - DETR добавляет позиционные эмбеддинги к скрытым состояниям на каждом слое само-внимания и кросс-внимания перед проекцией в запросы и ключи. Для позиционных эмбеддингов изображения можно выбрать фиксированные синусоидальные или обучаемые абсолютные позиционные эмбеддинги. По умолчанию параметр `position_embedding_type` в [DetrConfig](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrConfig) установлен в значение `"sine"`. - В ходе обучения авторы DETR обнаружили, что использование вспомогательных потерь в декодере помогает модели, в частности, выводить правильное количество объектов каждого класса. Если установить параметр `auxiliary_loss` в [DetrConfig](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrConfig) в значение `True`, то после каждого слоя декодера будут добавлены предсказательные нейронные сети и венгерские потери (при этом FFN разделяют параметры). - Если вы хотите обучать модель в распределённой среде на нескольких узлах, необходимо обновить переменную *num_boxes* в классе *DetrLoss* файла *modeling_detr.py*. При обучении на нескольких узлах это значение должно быть равно среднему числу целевых боксов по всем узлам, как показано в исходной реализации [здесь](https://github.com/facebookresearch/detr/blob/a54b77800eb8e64e3ad0d8237789fcbf2f8350c5/models/detr.py#L227-L232). - [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection) и [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) можно инициализировать с любым свёрточным бэкбоном, доступным в [timm library](https://github.com/rwightman/pytorch-image-models). Например, для инициализации с бэкбоном MobileNet необходимо установить атрибут `backbone` объекта [DetrConfig](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrConfig) в значение `"tf_mobilenetv3_small_075"`, а затем инициализировать модель с этим конфигом. - DER изменяет размер входных изображений так, чтобы кратчайшая сторона была не менее определённого количества пикселей, а наибольшая — не более 1333 пикселей. Во время обучения используется масштабное аугментация, при которой кратчайшая сторона случайно устанавливается в диапазоне от 480 до 800 пикселей. Во время инференса кратчайшая сторона устанавливается в 800 пикселей. Для подготовки изображений (и необязательных аннотаций в формате COCO) для модели можно использовать [DetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor). Из-за такого изменения размера изображения в батче могут иметь разные размеры. DETR решает эту проблему, дополняя изображения до наибольшего размера в батче и создавая пиксельную маску, которая указывает, какие пиксели являются реальными, а какие — дополнением. Альтернативно, можно также определить собственную `collate_fn` для объединения изображений в батч, используя `~transformers.DetrImageProcessor.pad_and_create_pixel_mask`. - Размер изображений определяет объём используемой памяти, а значит, и значение `batch_size`. Рекомендуется использовать размер батча 2 на каждый GPU. Подробнее — в [этом треде на GitHub](https://github.com/facebookresearch/detr/issues/150). Существует три других способа создать экземпляр модели DETR (в зависимости от ваших предпочтений): - Вариант 1: Инициализация DETR с предобученными весами для всей модели ```python from transformers import DetrForObjectDetection model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto") ``` - Вариант 2: Инициализация DETR со случайными весами для Transformer, но с предобученными весами для backbone ```python from transformers import DetrConfig, DetrForObjectDetection config = DetrConfig() model = DetrForObjectDetection(config) ``` - Вариант 3: Инициализация DETR со случайными весами для backbone + Transformer ```python config = DetrConfig() model = DetrForObjectDetection(config) ``` В качестве резюме рассмотрите следующую таблицу: | Задача | Обнаружение объектов | Сегментация экземпляров | Паноптическая сегментация | |------|------------------|-----------------------|-----------------------| | **Описание** | Предсказание ограничивающих прямоугольников и классов объектов на изображении | Предсказание масок вокруг объектов (т. е. экземпляров) на изображении | Предсказание масок вокруг обоих объектов (т.е. экземпляров), а также «stuff» (т.е. фоновых объектов, таких как деревья и дороги) на изображении | | **Модель** | [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection) | [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) | [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) | | **Пример датасета** | Детекция COCO | детекция COCO, паноптическая сегментация COCO | COCO panoptic | | **Формат аннотаций, которые нужно передать в** [DetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor) | {'image_id': `int`, 'annotations': `list[Dict]`}, где каждый Dict является аннотацией объекта COCO | {'image_id': `int`, 'annotations': `list[Dict]`} (в случае COCO detection) или {'file_name': `str`, 'image_id': `int`, 'segments_info': `list[Dict]`} (в случае COCO panoptic) | {'file_name': `str`, 'image_id': `int`, 'segments_info': `list[Dict]`} и masks_path (путь к каталогу, содержащему файлы PNG с масками) | | **Постобработка** (т. е. преобразование вывода модели в формат Pascal VOC) | `~transformers.DetrImageProcessor.post_process` | `~transformers.DetrImageProcessor.post_process_segmentation` | `~transformers.DetrImageProcessor.post_process_segmentation`, `~transformers.DetrImageProcessor.post_process_panoptic` | | **evaluators** | `CocoEvaluator` с `iou_types="bbox"` | `CocoEvaluator` с `iou_types="bbox"` или `"segm"` | `CocoEvaluator` с `iou_types="bbox"` или `"segm"`, `PanopticEvaluator` | - Кратко: данные следует подготовить в формате COCO detection или COCO panoptic, затем использовать [DetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor) для создания `pixel_values`, `pixel_mask` и необязательных `labels`, которые можно использовать для обучения (или дообучения) модели. - Для оценки необходимо сначала преобразовать выходные данные модели с помощью одного из методов постобработки [DetrImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor). Полученные результаты можно передать в `CocoEvaluator` или `PanopticEvaluator`, которые позволяют вычислять метрики, такие как средняя точность (mAP) и паноптическое качество (PQ). Последние объекты реализованы в [оригинальном репозитории](https://github.com/facebookresearch/detr). Дополнительную информацию об оценке см. в [примерах в ноутбуках](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR). ## Ресурсы - См. эти [ноутбуки](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR) с примерами дообучения [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection) и [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) на собственном наборе данных. ## DetrConfig[[transformers.DetrConfig]] #### transformers.DetrConfig[[transformers.DetrConfig]] ```python transformers.DetrConfig(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_channels: int = 3, num_queries: int = 100, 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, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, activation_function: str = 'relu', d_model: 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, position_embedding_type: str = 'sine', dilation: bool = False, class_cost: int = 1, bbox_cost: int = 5, giou_cost: int = 2, mask_loss_coefficient: int = 1, dice_loss_coefficient: int = 1, bbox_loss_coefficient: int = 5, giou_loss_coefficient: int = 2, eos_coefficient: float = 0.1) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/configuration_detr.py#L25) **Параметры:** is_encoder_decoder (`bool`, *необязательный*, по умолчанию `True`) : Используется ли модель в качестве энкодера/декодера. backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Конфигурация базовой модели. num_channels (`int`, *необязательный*, по умолчанию `3`) : Количество входных каналов. num_queries (`int`, *optional*, по умолчанию 100) : Количество запросов объектов, то есть слотов для обнаружения. Это максимальное число объектов, которые [ConditionalDetrModel](/docs/transformers/v5.23.0/ru/model_doc/conditional_detr#transformers.ConditionalDetrModel) может обнаружить на одном изображении. Для 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. encoder_layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность LayerDrop для энкодера. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556). decoder_layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность LayerDrop для декодера. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556). activation_function (`str`, *необязательный*, по умолчанию `relu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д. d_model (`int`, *необязательный*, по умолчанию `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`) : Использовать ли вспомогательные потери декодирования (потери на каждом слое декодера). position_embedding_type (`str`, *необязательный*, по умолчанию `"sine"`) : Тип позиционных эмбеддингов, применяемых поверх признаков изображения. Одно из значений `"sine"` или `"learned"`. dilation (`bool`, *необязательный*, по умолчанию `False`) : Заменять ли stride на dilation в последнем свёрточном блоке (DC5). Поддерживается только при `use_timm_backbone` = `True`. class_cost (`int`, *optional*, по умолчанию `1`) : Относительный вес ошибки классификации в стоимости венгерского сопоставления. bbox_cost (`int`, *optional*, по умолчанию `5`) : Относительный вес ошибки L1 для ограничивающих прямоугольников в стоимости венгерского сопоставления. giou_cost (`int`, *optional*, по умолчанию `2`) : Относительный вес обобщённой функции потерь IoU в стоимости венгерского сопоставления. mask_loss_coefficient (`int`, *optional*, по умолчанию `1`) : Относительный вес фокальной функции потерь в функции потерь паноптической сегментации. dice_loss_coefficient (`int`, *optional*, по умолчанию `1`) : Относительный вес функции потерь dice в функции потерь паноптической сегментации. bbox_loss_coefficient (`int`, *optional*, по умолчанию `5`) : Относительный вес потери L1 для ограничивающих прямоугольников в потере паноптической сегментации. giou_loss_coefficient (`int`, *optional*, по умолчанию `2`) : Относительный вес обобщённой функции потерь IoU в функции потерь паноптической сегментации. eos_coefficient (`float`, *необязательный*, по умолчанию `0.1`) : Относительный вес класса «нет объекта» в функции потерь обнаружения объектов. Это класс конфигурации для хранения настроек модели DetrModel. Он используется для создания модели Detr в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [facebook/detr-resnet-50](https://huggingface.co/facebook/detr-resnet-50) Объекты конфигурации наследуются от [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 DetrConfig, DetrModel >>> # Initializing a DETR facebook/detr-resnet-50 style configuration >>> configuration = DetrConfig() >>> # Initializing a model (with random weights) from the facebook/detr-resnet-50 style configuration >>> model = DetrModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## DetrImageProcessor[[transformers.DetrImageProcessor]] #### transformers.DetrImageProcessor[[transformers.DetrImageProcessor]] ```python transformers.DetrImageProcessor(**kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L426) **Параметры:** 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`) : Управляет преобразованием аннотаций в формат, ожидаемый моделью DETR. Преобразует ограничивающие рамки в формат `(center_x, center_y, width, height)` в диапазоне `[0, 1]`. Может быть переопределён параметром `do_convert_annotations` в методе `preprocess`. Создаёт процессор изображений DetrImageProcessor. #### preprocess[[transformers.DetrImageProcessor.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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L681) **Параметры:** 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`) : Управляет преобразованием аннотаций в формат, ожидаемый моделью 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.DetrImageProcessor.post_process_object_detection]] ```python post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L823) **Параметры:** outputs (`DetrObjectDetectionOutput`) : Сырые выходные данные модели. threshold (`float`, *необязательный*) : Порог оценки для сохранения предсказаний обнаружения объектов. target_sizes (`torch.Tensor` или `list[tuple[int, int]]`, *необязательный*) : тензор формы `(batch_size, 2)` или список кортежей (`tuple[int, int]`), содержащих целевой размер `(height, width)` каждого изображения в батче. Если не задано, предсказания не будут изменены в размере. **Возвращает:** `list[Dict]` Список словарей, где каждый словарь содержит оценки, метки и рамки для изображения в батче, как их предсказала модель. Преобразует необработанный вывод [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection) в итоговые ограничивающие прямоугольники в формате (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Поддерживается только PyTorch. #### post_process_semantic_segmentation[[transformers.DetrImageProcessor.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L876) **Параметры:** outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation)) : Сырые выходные данные модели. target_sizes (`list[tuple[int, int]]`, *необязательный*) : Список кортежей (`tuple[int, int]`), содержащих целевой размер (высота, ширина) каждого изображения в батче. Если не задано, предсказания не будут масштабироваться. return_segmentation_scores (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли возвращать оценки сегментации вместе с картой сегментации. Если `True`, каждый элемент возвращаемого списка представляет собой `SemanticSegmentationPostProcessorOutput` с полями `segmentation` (идентификаторы классов, форма `(height, width)`) и `segmentation_scores` (форма `(num_classes, height, width)`). **Возвращает:** `list[torch.Tensor]` или `list[SemanticSegmentationPostProcessorOutput]` Если `return_segmentation_scores=False` (по умолчанию), возвращается список длины `batch_size`, где каждый элемент — карта сегментации формы `(height, width)` с идентификаторами классов. Если `return_segmentation_scores=True`, возвращается список объектов `SemanticSegmentationPostProcessorOutput` с полями `segmentation` (идентификаторы классов, форма `(height, width)`) и `segmentation_scores` (форма `(num_classes, height, width)`). В обоих случаях `(height, width)` соответствует целевому размеру (если указан `target_sizes`). Преобразует выход [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) в карты семантической сегментации. Поддерживается только PyTorch. #### post_process_instance_segmentation[[transformers.DetrImageProcessor.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L947) **Параметры:** outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation)) : Сырые выходные данные модели. threshold (`float`, *optional*, по умолчанию 0.5) : Порог вероятности для сохранения предсказанных масок экземпляров. mask_threshold (`float`, *optional*, по умолчанию 0.5) : Порог, используемый при преобразовании предсказанных масок в бинарные значения. overlap_mask_area_threshold (`float`, *optional*, по умолчанию 0.8) : Порог площади маски перекрытия для слияния или удаления мелких отсоединённых частей внутри каждой бинарной маски экземпляра. target_sizes (`list[Tuple]`, *необязательный*) : Список длины (batch_size), где каждый элемент списка (`tuple[int, int]]`) соответствует запрашиваемому конечному размеру (высота, ширина) каждого предсказания. Если не задано, предсказания не будут изменены в размере. return_coco_annotation (`bool`, *необязательный*) : По умолчанию `False`. Если установлено в `True`, карты сегментации возвращаются в формате COCO run-length encoding (RLE). **Возвращает:** `list[Dict]` Список словарей, по одному на изображение, где каждый словарь содержит два ключа: - **segmentation** -- тензор формы `(height, width)`, где каждый пиксель представляет `segment_id` или `list[List]` — кодирование сжатием (RLE) карты сегментации, если return_coco_annotation установлено в `True`. Устанавливается в `None`, если маска не найдена выше `threshold`. - **segments_info** -- словарь, содержащий дополнительную информацию о каждом сегменте. - **id** — целое число, представляющее `segment_id`. - **label_id** — целое число, представляющее идентификатор метки / семантического класса, соответствующий `segment_id`. - **score** -- Оценка предсказания для сегмента с `segment_id`. Преобразует выход [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) в предсказания сегментации объектов. Поддерживается только PyTorch. #### post_process_panoptic_segmentation[[transformers.DetrImageProcessor.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L1030) **Параметры:** outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation)) : Выходные данные [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation). threshold (`float`, *optional*, по умолчанию 0.5) : Порог вероятности для сохранения предсказанных масок экземпляров. mask_threshold (`float`, *optional*, по умолчанию 0.5) : Порог, используемый при преобразовании предсказанных масок в бинарные значения. overlap_mask_area_threshold (`float`, *optional*, по умолчанию 0.8) : Порог площади маски перекрытия для слияния или удаления мелких отсоединённых частей внутри каждой бинарной маски экземпляра. label_ids_to_fuse (`Set[int]`, *необязательный*) : Все экземпляры меток в этом состоянии будут объединены. Например, можно утверждать, что на изображении может быть только одно небо, но несколько человек, поэтому идентификатор метки «небо» будет включён в этот набор, а идентификатор метки «человек» — нет. target_sizes (`list[Tuple]`, *необязательный*) : Список длины (batch_size), где каждый элемент списка (`tuple[int, int]]`) соответствует запрашиваемому конечному размеру (высота, ширина) каждого предсказания в батче. Если не задано, предсказания не будут изменены в размере. **Возвращает:** `list[Dict]` Список словарей, по одному на изображение, где каждый словарь содержит два ключа: - **segmentation** — тензор формы `(height, width)`, где каждый пиксель представляет `segment_id` или `None`, если маска не найдена выше `threshold`. Если указано `target_sizes`, сегментация масштабируется до соответствующего элемента `target_sizes`. - **segments_info** -- словарь, содержащий дополнительную информацию о каждом сегменте. - **id** — целое число, представляющее `segment_id`. - **label_id** — целое число, представляющее идентификатор метки / семантического класса, соответствующий `segment_id`. - **was_fused** -- булево значение, `True`, если `label_id` содержалось в `label_ids_to_fuse`, иначе `False`. Несколько экземпляров одного и того же класса / метки были объединены и получили единый `segment_id`. - **score** -- Оценка предсказания для сегмента с `segment_id`. Преобразует выход [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) в предсказания паноптической сегментации изображений. Поддерживается только PyTorch. ## DetrImageProcessorPil[[transformers.DetrImageProcessorPil]] #### transformers.DetrImageProcessorPil[[transformers.DetrImageProcessorPil]] ```python transformers.DetrImageProcessorPil(**kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L432) **Параметры:** 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`) : Управляет преобразованием аннотаций в формат, ожидаемый моделью DETR. Преобразует ограничивающие рамки в формат `(center_x, center_y, width, height)` в диапазоне `[0, 1]`. Может быть переопределён параметром `do_convert_annotations` в методе `preprocess`. Создаёт процессор изображений DetrImageProcessor. #### preprocess[[transformers.DetrImageProcessorPil.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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L700) **Параметры:** 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`) : Управляет преобразованием аннотаций в формат, ожидаемый моделью 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.DetrImageProcessorPil.post_process_object_detection]] ```python post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L845) **Параметры:** outputs (`DetrObjectDetectionOutput`) : Сырые выходные данные модели. threshold (`float`, *необязательный*) : Порог оценки для сохранения предсказаний обнаружения объектов. target_sizes (`torch.Tensor` или `list[tuple[int, int]]`, *необязательный*) : тензор формы `(batch_size, 2)` или список кортежей (`tuple[int, int]`), содержащих целевой размер `(height, width)` каждого изображения в батче. Если не задано, предсказания не будут изменены в размере. **Возвращает:** `list[Dict]` Список словарей, где каждый словарь содержит оценки, метки и рамки для изображения в батче, как их предсказала модель. Преобразует необработанный вывод [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection) в итоговые ограничивающие прямоугольники в формате (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Поддерживается только PyTorch. #### post_process_semantic_segmentation[[transformers.DetrImageProcessorPil.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L899) **Параметры:** outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation)) : Сырые выходные данные модели. target_sizes (`list[tuple[int, int]]`, *необязательный*) : Список кортежей (`tuple[int, int]`), содержащих целевой размер (высота, ширина) каждого изображения в батче. Если не задано, предсказания не будут масштабироваться. return_segmentation_scores (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли возвращать оценки сегментации вместе с картой сегментации. Если `True`, каждый элемент возвращаемого списка представляет собой `SemanticSegmentationPostProcessorOutput` с полями `segmentation` (идентификаторы классов, форма `(height, width)`) и `segmentation_scores` (форма `(num_classes, height, width)`). **Возвращает:** `list[torch.Tensor]` или `list[SemanticSegmentationPostProcessorOutput]` Если `return_segmentation_scores=False` (по умолчанию), возвращается список длины `batch_size`, где каждый элемент — карта сегментации формы `(height, width)` с идентификаторами классов. Если `return_segmentation_scores=True`, возвращается список объектов `SemanticSegmentationPostProcessorOutput` с полями `segmentation` (идентификаторы классов, форма `(height, width)`) и `segmentation_scores` (форма `(num_classes, height, width)`). В обоих случаях `(height, width)` соответствует целевому размеру (если указан `target_sizes`). Преобразует выход [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) в карты семантической сегментации. Поддерживается только PyTorch. #### post_process_instance_segmentation[[transformers.DetrImageProcessorPil.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L971) **Параметры:** outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation)) : Сырые выходные данные модели. threshold (`float`, *optional*, по умолчанию 0.5) : Порог вероятности для сохранения предсказанных масок экземпляров. mask_threshold (`float`, *optional*, по умолчанию 0.5) : Порог, используемый при преобразовании предсказанных масок в бинарные значения. overlap_mask_area_threshold (`float`, *optional*, по умолчанию 0.8) : Порог площади маски перекрытия для слияния или удаления мелких отсоединённых частей внутри каждой бинарной маски экземпляра. target_sizes (`list[Tuple]`, *необязательный*) : Список длины (batch_size), где каждый элемент списка (`tuple[int, int]]`) соответствует запрашиваемому конечному размеру (высота, ширина) каждого предсказания. Если не задано, предсказания не будут изменены в размере. return_coco_annotation (`bool`, *необязательный*) : По умолчанию `False`. Если установлено в `True`, карты сегментации возвращаются в формате COCO run-length encoding (RLE). **Возвращает:** `list[Dict]` Список словарей, по одному на изображение, где каждый словарь содержит два ключа: - **segmentation** -- тензор формы `(height, width)`, где каждый пиксель представляет `segment_id` или `list[List]` — кодирование сжатием (RLE) карты сегментации, если return_coco_annotation установлено в `True`. Устанавливается в `None`, если маска не найдена выше `threshold`. - **segments_info** -- словарь, содержащий дополнительную информацию о каждом сегменте. - **id** — целое число, представляющее `segment_id`. - **label_id** — целое число, представляющее идентификатор метки / семантического класса, соответствующий `segment_id`. - **score** -- Оценка предсказания для сегмента с `segment_id`. Преобразует выход [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) в предсказания сегментации объектов. Поддерживается только PyTorch. #### post_process_panoptic_segmentation[[transformers.DetrImageProcessorPil.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L1055) **Параметры:** outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation)) : Выходные данные [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation). threshold (`float`, *optional*, по умолчанию 0.5) : Порог вероятности для сохранения предсказанных масок экземпляров. mask_threshold (`float`, *optional*, по умолчанию 0.5) : Порог, используемый при преобразовании предсказанных масок в бинарные значения. overlap_mask_area_threshold (`float`, *optional*, по умолчанию 0.8) : Порог площади маски перекрытия для слияния или удаления мелких отсоединённых частей внутри каждой бинарной маски экземпляра. label_ids_to_fuse (`Set[int]`, *необязательный*) : Все экземпляры меток в этом состоянии будут объединены. Например, можно утверждать, что на изображении может быть только одно небо, но несколько человек, поэтому идентификатор метки «небо» будет включён в этот набор, а идентификатор метки «человек» — нет. target_sizes (`list[Tuple]`, *необязательный*) : Список длины (batch_size), где каждый элемент списка (`tuple[int, int]]`) соответствует запрашиваемому конечному размеру (высота, ширина) каждого предсказания в батче. Если не задано, предсказания не будут изменены в размере. **Возвращает:** `list[Dict]` Список словарей, по одному на изображение, где каждый словарь содержит два ключа: - **segmentation** — тензор формы `(height, width)`, где каждый пиксель представляет `segment_id` или `None`, если маска не найдена выше `threshold`. Если указано `target_sizes`, сегментация масштабируется до соответствующего элемента `target_sizes`. - **segments_info** -- словарь, содержащий дополнительную информацию о каждом сегменте. - **id** — целое число, представляющее `segment_id`. - **label_id** — целое число, представляющее идентификатор метки / семантического класса, соответствующий `segment_id`. - **was_fused** -- булево значение, `True`, если `label_id` содержалось в `label_ids_to_fuse`, иначе `False`. Несколько экземпляров одного и того же класса / метки были объединены и получили единый `segment_id`. - **score** -- Оценка предсказания для сегмента с `segment_id`. Преобразует выход [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) в предсказания паноптической сегментации изображений. Поддерживается только PyTorch. ## Специфические для DETR выходные данные[[transformers.models.detr.modeling_detr.DetrModelOutput]] #### transformers.models.detr.modeling_detr.DetrModelOutput[[transformers.models.detr.modeling_detr.DetrModelOutput]] ```python transformers.models.detr.modeling_detr.DetrModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, intermediate_hidden_states: typing.Optional[torch.Tensor] = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L76) **Параметры:** 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/v5.23.0/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 внимания, используемые для вычисления взвешенного среднего в головах self-attention. intermediate_hidden_states (`torch.Tensor` формы `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *необязательный*, возвращается, если `config.auxiliary_loss=True`) : Промежуточные активации декодера, то есть выход каждого слоя декодера, каждый из которых прошёл через layernorm. Базовый класс для выходов модели DETR с архитектурой «кодировщик-декодировщик». Этот класс добавляет к Seq2SeqModelOutput один атрибут, а именно необязательный стек промежуточных активаций декодера, то есть выходы каждого слоя декодера, каждый из которых прошёл через нормализацию слоя. Это полезно при обучении модели с дополнительными потерями декодирования. #### transformers.models.detr.modeling_detr.DetrObjectDetectionOutput[[transformers.models.detr.modeling_detr.DetrObjectDetectionOutput]] ```python transformers.models.detr.modeling_detr.DetrObjectDetectionOutput(loss: typing.Optional[torch.Tensor] = None, loss_dict: dict | None = None, logits: typing.Optional[torch.Tensor] = None, pred_boxes: typing.Optional[torch.Tensor] = None, auxiliary_outputs: list[dict] | None = None, last_hidden_state: typing.Optional[torch.Tensor] = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L92) **Параметры:** 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] относительно размера каждого отдельного изображения в батче (игнорируя возможное выравнивание). Для получения ненормализованных границ используйте [post_process_object_detection()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Тип результата [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection). #### transformers.models.detr.modeling_detr.DetrSegmentationOutput[[transformers.models.detr.modeling_detr.DetrSegmentationOutput]] ```python transformers.models.detr.modeling_detr.DetrSegmentationOutput(loss: typing.Optional[torch.Tensor] = None, loss_dict: dict | None = None, logits: typing.Optional[torch.Tensor] = None, pred_boxes: typing.Optional[torch.Tensor] = None, pred_masks: typing.Optional[torch.Tensor] = None, auxiliary_outputs: list[dict] | None = None, last_hidden_state: typing.Optional[torch.Tensor] = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L135) **Параметры:** 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] относительно размера каждого отдельного изображения в батче (игнорируя возможное выравнивание). Для получения ненормализованных границ используйте [post_process_object_detection()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection). pred_masks (`torch.Tensor` формы `(batch_size, num_queries, height/4, width/4)`) : Логиты сегментационных масок для всех запросов. См. также [post_process_semantic_segmentation()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation) или [post_process_instance_segmentation()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation) [post_process_panoptic_segmentation()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation) для оценки семантических, инстантных и паноптических сегментационных масок соответственно. 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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Тип результата [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation). ## DetrModel[[transformers.DetrModel]] #### transformers.DetrModel[[transformers.DetrModel]] ```python transformers.DetrModel(config: DetrConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1115) **Параметры:** config ([DetrConfig](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Базовая модель DETR (состоящая из backbone и encoder-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.DetrModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1144) **Параметры:** 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)`, *необязательный*) : Маска для исключения выполнения внимания для определённых запросов объектов в декодере. Значения маски выбираются из `[0, 1]`: - 1 для запросов, которые **не замаскированы**, - 0 для запросов, которые **замаскированы**. 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 + проекционного слоя), можно напрямую передать сглаженное представление изображения. Полезно для обхода визуального backbone. decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, num_queries, hidden_size)`, *необязательно*) : По желанию, вместо инициализации запросов тензором нулей, можно передать встроенное представление напрямую. Полезно для задач, требующих кастомной инициализации запросов. **Возвращает:** [DetrModelOutput](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) или `tuple(torch.Tensor)` [DetrModelOutput](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных. Метод forward класса [DetrModel](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrModel) переопределяет специальный метод `__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/v5.23.0/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. Примеры: ```python >>> from transformers import AutoImageProcessor, DetrModel >>> 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("facebook/detr-resnet-50") >>> model = DetrModel.from_pretrained("facebook/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, 100, 256] ``` ## DetrForObjectDetection[[transformers.DetrForObjectDetection]] #### transformers.DetrForObjectDetection[[transformers.DetrForObjectDetection]] ```python transformers.DetrForObjectDetection(config: DetrConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1309) **Параметры:** config ([DetrConfig](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель DETR (состоящая из backbone и encoder-decoder Transformer) с головками для обнаружения объектов, предназначенная для таких задач, как COCO detection. Эта модель наследуется от [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.DetrForObjectDetection.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = 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, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1327) **Параметры:** 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)`, *необязательный*) : Маска для исключения выполнения внимания для определённых запросов объектов в декодере. Значения маски выбираются из `[0, 1]`: - 1 для запросов, которые **не замаскированы**, - 0 для запросов, которые **замаскированы**. 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 + проекционного слоя), можно напрямую передать сглаженное представление изображения. Полезно для обхода визуального 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)`. **Возвращает:** [DetrObjectDetectionOutput](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) или `tuple(torch.Tensor)` [DetrObjectDetectionOutput](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных. Метод forward класса [DetrForObjectDetection](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForObjectDetection) переопределяет специальный метод `__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] относительно размера каждого отдельного изображения в батче (игнорируя возможное выравнивание). Для получения ненормализованных границ используйте [post_process_object_detection()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.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, DetrForObjectDetection >>> import torch >>> 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("facebook/detr-resnet-50") >>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") >>> inputs = image_processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax) >>> target_sizes = torch.tensor([image.size[::-1]]) >>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, 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.998 at location [40.16, 70.81, 175.55, 117.98] Detected remote with confidence 0.996 at location [333.24, 72.55, 368.33, 187.66] Detected couch with confidence 0.995 at location [-0.02, 1.15, 639.73, 473.76] Detected cat with confidence 0.999 at location [13.24, 52.05, 314.02, 470.93] Detected cat with confidence 0.999 at location [345.4, 23.85, 640.37, 368.72] ``` ## DetrForSegmentation[[transformers.DetrForSegmentation]] #### transformers.DetrForSegmentation[[transformers.DetrForSegmentation]] ```python transformers.DetrForSegmentation(config: DetrConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1441) **Параметры:** config ([DetrConfig](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель DETR (состоящая из backbone и encoder-decoder Transformer) с сегментационным head сверху, для задач, таких как COCO panoptic. Эта модель наследуется от [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.DetrForSegmentation.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = 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, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1463) **Параметры:** 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)`, *необязательный*) : Маска для исключения выполнения внимания для определённых запросов объектов в декодере. Значения маски выбираются из `[0, 1]`: - 1 для запросов, которые **не замаскированы**, - 0 для запросов, которые **замаскированы**. 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, которые недоступны при обходе backbone с помощью inputs_embeds. decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, num_queries, hidden_size)`, *необязательно*) : По желанию, вместо инициализации запросов тензором нулей, можно передать встроенное представление напрямую. Полезно для задач, требующих кастомной инициализации запросов. labels (`list[Dict]` длины `(batch_size,)`, *необязательный*) : Метки для вычисления потерь bipartite matching, DICE/F-1 и Focal. Список словарей, каждый из которых содержит как минимум следующие три ключа: 'class_labels', 'boxes' и 'masks' (соответственно метки классов, ограничивающие рамки и маски сегментации для изображения в батче). Сами метки классов должны быть `torch.LongTensor` длины `(number of bounding boxes in the image,)`, рамки — `torch.Tensor` формы `(number of bounding boxes in the image, 4)`, а маски — `torch.Tensor` формы `(number of bounding boxes in the image, height, width)`. **Возвращает:** [DetrSegmentationOutput](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) или `tuple(torch.Tensor)` [DetrSegmentationOutput](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных. Метод forward класса [DetrForSegmentation](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrForSegmentation) переопределяет специальный метод `__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] относительно размера каждого отдельного изображения в батче (игнорируя возможное выравнивание). Для получения ненормализованных границ используйте [post_process_object_detection()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection). - **pred_masks** (`torch.Tensor` формы `(batch_size, num_queries, height/4, width/4)`) -- Логиты сегментационных масок для всех запросов. См. также [post_process_semantic_segmentation()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation) или [post_process_instance_segmentation()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation) [post_process_panoptic_segmentation()](/docs/transformers/v5.23.0/ru/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation) для оценки семантических, инстантных и паноптических сегментационных масок соответственно. - **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 >>> import io >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from PIL import Image >>> import torch >>> import numpy >>> from transformers import AutoImageProcessor, DetrForSegmentation >>> from transformers.image_transforms import rgb_to_id >>> 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("facebook/detr-resnet-50-panoptic") >>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic") >>> # prepare image for the model >>> inputs = image_processor(images=image, return_tensors="pt") >>> # forward pass >>> outputs = model(**inputs) >>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps >>> # Segmentation results are returned as a list of dictionaries >>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)]) >>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found >>> panoptic_seg = result[0]["segmentation"] >>> panoptic_seg.shape torch.Size([300, 500]) >>> # Get prediction score and segment_id to class_id mapping of each segment >>> panoptic_segments_info = result[0]["segments_info"] >>> len(panoptic_segments_info) 5 ```