# RT-DETR

## Aperçu

Le modèle RT-DETR a été proposé dans [DETRs Beat YOLOs on Real-time Object Detection](https://huggingface.co/papers/2304.08069) par Wenyu Lv, Yian Zhao, Shangliang Xu, Jinman Wei, Guanzhong Wang, Cheng Cui, Yuning Du, Qingqing Dang, Yi Liu.

RT-DETR est un modèle de détection d'objets, l'acronyme de « Real-Time DEtection Transformer ». Ce modèle est conçu pour effectuer des tâches de détection d'objets en mettant l'accent sur la performance en temps réel tout en maintenant une haute précision. En s'appuyant sur l'architecture transformer, qui a gagné une popularité considérable dans divers domaines de l'apprentissage profond, RT-DETR traite les images afin d'identifier et de localiser plusieurs objets qui s'y trouvent.

L'abstract de l'article est le suivant :

*Récemment, les détecteurs basés sur des transformers de bout en bout (DETR) ont atteint des performances remarquables. Cependant, le problème du coût de calcul élevé des DETR n'a pas été traité de manière efficace, ce qui limite leur application pratique et les empêche de tirer pleinement parti des avantages de l'absence de post-traitement, tels que la suppression du maximum non maximal (NMS). Dans cet article, nous analysons d'abord l'influence du NMS sur la vitesse d'inférence des détecteurs d'objets en temps réel modernes, et nous établissons un benchmark de vitesse de bout en bout. Pour éviter le délai d'inférence causé par le NMS, nous proposons un Real-Time DEtection TRansformer (RT-DETR), le premier détecteur d'objets en temps réel de bout en bout à notre connaissance. Plus précisément, nous concevons un encodeur hybride efficace pour traiter efficacement les caractéristiques multi-échelles en découplant l'interaction intra-échelle et la fusion inter-échelles, et nous proposons une sélection de requêtes sensible à l'IoU pour améliorer l'initialisation des requêtes d'objets. En outre, notre détecteur proposé permet un ajustement flexible de la vitesse d'inférence en utilisant différentes couches de décodeur sans avoir besoin de réentraîner, ce qui facilite l'application pratique des détecteurs d'objets en temps réel. Notre RT-DETR-L atteint 53,0 % d'AP sur COCO val2017 et 114 FPS sur GPU T4, tandis que RT-DETR-X atteint 54,8 % d'AP et 74 FPS, surpassant tous les détecteurs YOLO de la même échelle en termes de vitesse et de précision. De plus, notre RT-DETR-R50 atteint 53,1 % d'AP et 108 FPS, surpassant DINO-Deformable-DETR-R50 de 2,2 % d'AP en précision et d'environ 21 fois en FPS.*

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

 Performance de RT-DETR par rapport aux modèles YOLO. Extrait de l'article original.

La version du modèle a été proposée par [rafaelpadilla](https://huggingface.co/rafaelpadilla) et [sangbumchoi](https://github.com/SangbumChoi). Le code d'origine est disponible [ici](https://github.com/lyuwenyu/RT-DETR/).

## Conseils d'utilisation

Initialement, une image est traitée à l'aide d'un réseau de neurones convolutif pré-entraîné, plus précisément une variante Resnet-D, comme indiqué dans le code d'origine. Ce réseau extrait les caractéristiques des trois dernières couches de l'architecture. Ensuite, un encodeur hybride est utilisé pour convertir les caractéristiques multi-échelles en un tableau séquentiel de caractéristiques d'image. Puis, un décodeur, équipé de têtes de prédiction auxiliaires, est employé pour affiner les requêtes d'objets. Ce processus permet la génération directe des boîtes englobantes, éliminant le besoin de tout post-traitement supplémentaire pour obtenir les logits et les coordonnées des boîtes englobantes. Le modèle est conçu pour être utilisé sur des images redimensionnées à la taille 640x640 avec l'ImageProcessor correspondant. Le redimensionnement vers d'autres tailles dégradera généralement les performances.

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

from transformers import RTDetrForObjectDetection, RTDetrImageProcessor

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

image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd", device_map="auto")

inputs = image_processor(images=image, return_tensors="pt").to(model.device)

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

results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([(image.height, image.width)]), threshold=0.3)

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}")
sofa: 0.97 [0.14, 0.38, 640.13, 476.21]
cat: 0.96 [343.38, 24.28, 640.14, 371.5]
cat: 0.96 [13.23, 54.18, 318.98, 472.22]
remote: 0.95 [40.11, 73.44, 175.96, 118.48]
remote: 0.92 [333.73, 76.58, 369.97, 186.99]
```

## Ressources

Une liste de ressources officielles de Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec RT-DETR.

- Voir aussi : [Guide de la tâche de détection d'objets](../tasks/object_detection).
- Des notebooks concernant l’inférence et l’ajustement fin de RT-DETR sur un jeu de données personnalisé sont disponibles [ici](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/RT-DETR). 🌎

## RTDetrConfig[[transformers.RTDetrConfig]]

#### transformers.RTDetrConfig[[transformers.RTDetrConfig]]

```python
transformers.RTDetrConfig(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, initializer_range: float = 0.01, initializer_bias_prior_prob: float | None = None, layer_norm_eps: float = 1e-05, batch_norm_eps: float = 1e-05, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, freeze_backbone_batch_norms: bool = True, encoder_hidden_dim: int = 256, encoder_in_channels: list[int] | tuple[int, ...] = (512, 1024, 2048), feat_strides: list[int] | tuple[int, ...] = (8, 16, 32), encoder_layers: int = 1, encoder_ffn_dim: int = 1024, encoder_attention_heads: int = 8, dropout: float | int = 0.0, activation_dropout: float | int = 0.0, encode_proj_layers: list[int] | tuple[int, ...] = (2,), positional_encoding_temperature: int = 10000, encoder_activation_function: str = 'gelu', activation_function: str = 'silu', eval_size: int | None = None, normalize_before: bool = False, hidden_expansion: float = 1.0, d_model: int = 256, num_queries: int = 300, decoder_in_channels: list[int] | tuple[int, ...] = (256, 256, 256), decoder_ffn_dim: int = 1024, num_feature_levels: int = 3, decoder_n_points: int = 4, decoder_layers: int = 6, decoder_attention_heads: int = 8, decoder_activation_function: str = 'relu', attention_dropout: float | int = 0.0, num_denoising: int = 100, label_noise_ratio: float = 0.5, box_noise_scale: float = 1.0, learn_initial_query: bool = False, anchor_image_size: int | list[int] | None = None, disable_custom_kernels: bool = True, with_box_refine: bool = True, matcher_alpha: float = 0.25, matcher_gamma: float = 2.0, matcher_class_cost: float = 2.0, matcher_bbox_cost: float = 5.0, matcher_giou_cost: float = 2.0, use_focal_loss: bool = True, auxiliary_loss: bool = True, focal_loss_alpha: float = 0.75, focal_loss_gamma: float = 2.0, weight_loss_vfl: float = 1.0, weight_loss_bbox: float = 5.0, weight_loss_giou: float = 2.0, eos_coefficient: float = 0.0001)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/configuration_rt_detr.py#L25)

**Paramètres :**

is_encoder_decoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle est utilisé comme encodeur/décodeur ou non.

initializer_range (`float`, *facultatif*, valeur par défaut `0.01`) : L'écart-type de truncated_normal_initializer pour l'initialisation de toutes les matrices de poids.

initializer_bias_prior_prob (`float`, *facultatif*) : La probabilité a priori utilisée par l'initialiseur de biais pour initialiser les biais de `enc_score_head` et `class_embed`. Si `None`, `prior_prob` est calculé comme `prior_prob = 1 / (num_labels + 1)` lors de l'initialisation des poids du modèle.

layer_norm_eps (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

batch_norm_eps (`float`, *facultatif*, par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation par lot.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : La configuration du modèle de base.

freeze_backbone_batch_norms (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut figer les couches de normalisation par lot dans le backbone.

encoder_hidden_dim (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées.

encoder_in_channels (`list`, *facultatif*, valeur par défaut `[512, 1024, 2048]`) : Entrées de caractéristiques multi-niveaux pour l'encodeur.

feat_strides (`list[int]`, *facultatif*, par défaut `[8, 16, 32]`) : Pas utilisés dans chaque carte de caractéristiques.

encoder_layers (`int`, *facultatif*, valeur par défaut `1`) : Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

encoder_ffn_dim (`int`, *facultatif*, par défaut `1024`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) dans l'encodeur.

encoder_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le ratio pour toutes les couches de dropout.

activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

encode_proj_layers (`list[int]`, *facultatif*, valeur par défaut `[2]`) : Index des couches projetées à utiliser dans l'encodeur.

positional_encoding_temperature (`int`, *facultatif*, valeur par défaut 10000) : Le paramètre de température utilisé pour créer les encodages positionnels.

encoder_activation_function (`str`, *facultatif*, par défaut `"gelu"`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) dans l'encodeur et le pooler. Si c'est une chaîne de caractères, `"gelu"`, `"relu"`, `"silu"` et `"gelu_new"` sont pris en charge.

activation_function (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

eval_size (`tuple[int, int]`, *facultatif*) : Hauteur et largeur utilisées pour calculer la hauteur et la largeur effectives des embeddings de position après prise en compte du pas (stride).

normalize_before (`bool`, *facultatif*, valeur par défaut `False`) : Détermine s'il faut appliquer la normalisation de couche dans la couche d'encodeur du transformer avant les modules d'auto-attention et de réseau de neurones à propagation avant.

hidden_expansion (`float`, *facultatif*, valeur par défaut 1.0) : Ratio d'expansion pour agrandir la taille de la dimension de RepVGGBlock et CSPRepLayer.

d_model (`int`, *facultatif*, par défaut `256`) : Taille des couches d'encodeur et de la couche pooler.

num_queries (`int`, *facultatif*, valeur par défaut 300) : Nombre de requêtes d'objets.

decoder_in_channels (`list`, *facultatif*, valeur par défaut `[256, 256, 256]`) : Dimensions des caractéristiques multi-niveaux pour le décodeur

decoder_ffn_dim (`int`, *facultatif*, valeur par défaut `1024`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.

num_feature_levels (`int`, *facultatif*, valeur par défaut : 3) : Le nombre de niveaux de caractéristiques d'entrée.

decoder_n_points (`int`, *facultatif*, valeur par défaut : 4) : Le nombre de clés échantillonnées à chaque niveau de fonction pour chaque tête d'attention dans le décodeur.

decoder_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

decoder_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

decoder_activation_function (`str`, *facultatif*, valeur par défaut `"relu"`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Si c'est une chaîne de caractères, `"gelu"`, `"relu"`, `"silu"` et `"gelu_new"` sont pris en charge.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

num_denoising (`int`, *facultatif*, valeur par défaut 100) : Nombre total de tâches ou requêtes de débruitage à utiliser pour le débruitage contrastif.

label_noise_ratio (`float`, *facultatif*, valeur par défaut 0,5) : La fraction d'étiquettes de débruitage auxquelles du bruit aléatoire doit être ajouté.

box_noise_scale (`float`, *facultatif*, valeur par défaut 1.0) : Échelle ou amplitude du bruit à ajouter aux boîtes englobantes.

learn_initial_query (`bool`, *facultatif*, par défaut `False`) : Indique si les embeddings de requête initiaux du décodeur doivent être appris pendant l'entraînement

anchor_image_size (`tuple[int, int]`, *facultatif*) : Hauteur et largeur de l'image d'entrée utilisée lors de l'évaluation pour générer les ancres de boîte englobante. Si la valeur est None, la génération automatique des ancres est appliquée.

disable_custom_kernels (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut désactiver les noyaux personnalisés.

with_box_refine (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut appliquer un raffinement itératif des boîtes englobantes, où chaque couche du décodeur affine les boîtes englobantes en fonction des prédictions de la couche précédente.

matcher_alpha (`float`, *facultatif*, valeur par défaut 0.25) : Paramètre alpha utilisé par le Hungarian Matcher.

matcher_gamma (`float`, *facultatif*, valeur par défaut 2.0) : Paramètre gamma utilisé par le Hungarian Matcher.

matcher_class_cost (`float`, *facultatif*, valeur par défaut 2.0) : Le poids relatif de la perte de classe utilisé par le Hungarian Matcher.

matcher_bbox_cost (`float`, *facultatif*, valeur par défaut 5.0) : Le poids relatif de la perte de boîte englobante utilisé par le Hungarian Matcher.

matcher_giou_cost (`float`, *facultatif*, valeur par défaut 2.0) : Le poids relatif de la perte giou utilisée par le Hungarian Matcher.

use_focal_loss (`bool`, *facultatif*, valeur par défaut `True`) : Paramètre indiquant si la focal loss doit être utilisée.

auxiliary_loss (`bool`, *facultatif*, valeur par défaut `True`) : Indique si les pertes de décodage auxiliaires (pertes à chaque couche du décodeur) doivent être utilisées.

focal_loss_alpha (`float`, *facultatif*, valeur par défaut 0.75) : Paramètre alpha utilisé pour calculer la perte focale.

focal_loss_gamma (`float`, *facultatif*, valeur par défaut 2.0) : Paramètre gamma utilisé pour calculer la perte focale.

weight_loss_vfl (`float`, *facultatif*, valeur par défaut 1.0) : Poids relatif de la perte varifocal dans la perte de détection d'objets.

weight_loss_bbox (`float`, *facultatif*, valeur par défaut 5.0) : Poids relatif de la perte de boîte englobante L1 dans la perte de détection d'objets.

weight_loss_giou (`float`, *facultatif*, valeur par défaut 2.0) : Poids relatif de la perte IoU généralisée dans la perte de détection d'objets.

eos_coefficient (`float`, *facultatif*, valeur par défaut `0.0001`) : Poids de classification relatif de la classe « no-object » dans la fonction de perte de détection d'objets.

Ceci est la classe de configuration destinée à stocker la configuration d'un RTDetrModel. Elle est utilisée pour instancier un modèle Rt Detr en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [PekingU/rtdetr_r50vd](https://huggingface.co/PekingU/rtdetr_r50vd)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemples :

```python
>>> from transformers import RTDetrConfig, RTDetrModel

>>> # Initializing a RT-DETR configuration
>>> configuration = RTDetrConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = RTDetrModel(configuration)

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

## RTDetrResNetConfig[[transformers.RTDetrResNetConfig]]

#### transformers.RTDetrResNetConfig[[transformers.RTDetrResNetConfig]]

```python
transformers.RTDetrResNetConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_channels: int = 3, embedding_size: int = 64, hidden_sizes: list[int] | tuple[int, ...] = (256, 512, 1024, 2048), depths: list[int] | tuple[int, ...] = (3, 4, 6, 3), layer_type: str = 'bottleneck', hidden_act: str = 'relu', downsample_in_first_stage: bool = False, downsample_in_bottleneck: bool = False, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/configuration_rt_detr_resnet.py#L25)

**Paramètres :**

num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

embedding_size (`int`, *facultatif*, par défaut `64`) : Dimension des embeddings et des états cachés.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(256, 512, 1024, 2048)`) : Dimension (taille cachée) à chaque étape du modèle.

depths (`list[int]`, *facultatif*, valeur par défaut `[3, 4, 6, 3]`) : Profondeur (nombre de couches) de chaque étape.

layer_type (`str`, *facultatif*, par défaut `"bottleneck"`) : La couche à utiliser, qui peut être soit `"basic"` (utilisée pour les modèles plus petits, comme resnet-18 ou resnet-34), soit `"bottleneck"` (utilisée pour les modèles plus grands, comme resnet-50 et au-delà).

hidden_act (`str`, *facultatif*, par défaut `"relu"`) : La fonction d'activation non linéaire dans chaque bloc. Si c'est une chaîne de caractères, `"gelu"`, `"relu"`, `"selu"` et `"gelu_new"` sont pris en charge.

downsample_in_first_stage (`bool`, *facultatif*, valeur par défaut `False`) : Si `True`, la première étape effectue un sous-échantillonnage des entrées en utilisant un `stride` de 2.

downsample_in_bottleneck (`bool`, *facultatif*, valeur par défaut `False`) : Si `True`, la première convolution 1x1 de ResNetBottleNeckLayer effectue un sous-échantillonnage des entrées en utilisant un `stride` de 2.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Rt Detr ResnetModel. Elle est utilisée pour instancier un modèle Rt Detr Resnet en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [microsoft/resnet-50](https://huggingface.co/microsoft/resnet-50)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :
```python
>>> from transformers import RTDetrResNetConfig, RTDetrResnetBackbone

>>> # Initializing a ResNet resnet-50 style configuration
>>> configuration = RTDetrResNetConfig()

>>> # Initializing a model (with random weights) from the resnet-50 style configuration
>>> model = RTDetrResnetBackbone(configuration)

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

## RTDetrImageProcessor[[transformers.RTDetrImageProcessor]]

#### transformers.RTDetrImageProcessor[[transformers.RTDetrImageProcessor]]

```python
transformers.RTDetrImageProcessor(**kwargs: *<class 'transformers.models.rt_detr.image_processing_rt_detr.RTDetrImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_rt_detr.py#L131)

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 640, 'width': 640}`) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.485, 0.456, 0.406]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.229, 0.224, 0.225]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

format (`str`, *kwargs*, *facultatif*, par défaut `AnnotationFormat.COCO_DETECTION`) : Format des données des annotations. L'une des valeurs "coco_detection" ou "coco_panoptic".

do_convert_annotations (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Contrôle la conversion des annotations au format attendu par le modèle RT_DETR. Convertit les boîtes englobantes au format `(center_x, center_y, width, height)` et dans l'intervalle `[0, 1]`. Peut être remplacé par le paramètre `do_convert_annotations` de la méthode `preprocess`.

Construit un processeur d’images RTDetrImageProcessor.

#### prétraiter[[transformers.RTDetrImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *<class 'transformers.models.rt_detr.image_processing_rt_detr.RTDetrImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_rt_detr.py#L370)

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

annotations (`AnnotationType` ou `list[AnnotationType]`, *facultatif*) : Annotations à transformer en fonction du bourrage appliqué aux images.

return_segmentation_masks (`bool`, *facultatif*, par défaut `self.return_segmentation_masks`) : Indique s'il faut retourner les masques de segmentation.

masks_path (`str` ou `pathlib.Path`, *facultatif*) : Chemin vers le répertoire contenant les masques de segmentation.

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

format (`str`, *kwargs*, *facultatif*, par défaut `AnnotationFormat.COCO_DETECTION`) : Format des données des annotations. L'une des valeurs "coco_detection" ou "coco_panoptic".

do_convert_annotations (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Contrôle la conversion des annotations au format attendu par le modèle RT_DETR. Convertit les boîtes englobantes au format `(center_x, center_y, width, height)` et dans l'intervalle `[0, 1]`. Peut être remplacé par le paramètre `do_convert_annotations` de la méthode `preprocess`.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

#### post_process_object_detection[[transformers.RTDetrImageProcessor.post_process_object_detection]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_rt_detr.py#L511)

**Paramètres :**

outputs (`DetrObjectDetectionOutput`) : Sorties brutes du modèle.

threshold (`float`, *facultatif*, valeur par défaut 0,5) : Seuil de score pour conserver les prédictions de détection d'objets.

target_sizes (`torch.Tensor` ou `list[tuple[int, int]]`, *facultatif*) : Tenseur de forme `(batch_size, 2)` ou liste de tuples (`tuple[int, int]`) contenant la taille cible `(height, width)` de chaque image du lot. Si non défini, les prédictions ne seront pas redimensionnées.

use_focal_loss (`bool` par défaut `True`) : Variable indiquant si la focal loss a été utilisée pour prédire les sorties. Si `True`, une fonction sigmoïde est appliquée pour calculer les scores de chaque détection, sinon, une fonction softmax est utilisée.

**Retourne :** `list[Dict]`

Une liste de dictionnaires, chaque dictionnaire contenant les scores, les étiquettes et les boîtes pour une image du lot, tels que prédits par le modèle.

Convertit la sortie brute de [DetrForObjectDetection](/docs/transformers/v5.23.0/fr/model_doc/detr#transformers.DetrForObjectDetection) en boîtes englobantes finales au format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Prend uniquement en charge PyTorch.

## RTDetrImageProcessorPil[[transformers.RTDetrImageProcessorPil]]

#### transformers.RTDetrImageProcessorPil[[transformers.RTDetrImageProcessorPil]]

```python
transformers.RTDetrImageProcessorPil(**kwargs: *<class 'transformers.models.rt_detr.image_processing_pil_rt_detr.RTDetrImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L130)

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 640, 'width': 640}`) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.485, 0.456, 0.406]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.229, 0.224, 0.225]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

format (`str`, *kwargs*, *facultatif*, par défaut `AnnotationFormat.COCO_DETECTION`) : Format des données des annotations. L'une des valeurs "coco_detection" ou "coco_panoptic".

do_convert_annotations (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Contrôle la conversion des annotations au format attendu par le modèle RT_DETR. Convertit les boîtes englobantes au format `(center_x, center_y, width, height)` et dans l'intervalle `[0, 1]`. Peut être remplacé par le paramètre `do_convert_annotations` de la méthode `preprocess`.

Construit un processeur d’images RTDetrImageProcessor.

#### prétraiter[[transformers.RTDetrImageProcessorPil.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *<class 'transformers.models.rt_detr.image_processing_pil_rt_detr.RTDetrImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L379)

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

annotations (`AnnotationType` ou `list[AnnotationType]`, *facultatif*) : Annotations à transformer en fonction du bourrage appliqué aux images.

return_segmentation_masks (`bool`, *facultatif*, par défaut `self.return_segmentation_masks`) : Indique s'il faut retourner les masques de segmentation.

masks_path (`str` ou `pathlib.Path`, *facultatif*) : Chemin vers le répertoire contenant les masques de segmentation.

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

format (`str`, *kwargs*, *facultatif*, par défaut `AnnotationFormat.COCO_DETECTION`) : Format des données des annotations. L'une des valeurs "coco_detection" ou "coco_panoptic".

do_convert_annotations (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Contrôle la conversion des annotations au format attendu par le modèle RT_DETR. Convertit les boîtes englobantes au format `(center_x, center_y, width, height)` et dans l'intervalle `[0, 1]`. Peut être remplacé par le paramètre `do_convert_annotations` de la méthode `preprocess`.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

#### post_process_object_detection[[transformers.RTDetrImageProcessorPil.post_process_object_detection]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L507)

**Paramètres :**

outputs (`DetrObjectDetectionOutput`) : Sorties brutes du modèle.

threshold (`float`, *facultatif*, valeur par défaut 0,5) : Seuil de score pour conserver les prédictions de détection d'objets.

target_sizes (`torch.Tensor` ou `list[tuple[int, int]]`, *facultatif*) : Tenseur de forme `(batch_size, 2)` ou liste de tuples (`tuple[int, int]`) contenant la taille cible `(height, width)` de chaque image du lot. Si non défini, les prédictions ne seront pas redimensionnées.

use_focal_loss (`bool` par défaut `True`) : Variable indiquant si la focal loss a été utilisée pour prédire les sorties. Si `True`, une fonction sigmoïde est appliquée pour calculer les scores de chaque détection, sinon, une fonction softmax est utilisée.

**Retourne :** `list[Dict]`

Une liste de dictionnaires, chaque dictionnaire contenant les scores, les étiquettes et les boîtes pour une image du lot, tels que prédits par le modèle.

Convertit la sortie brute de [DetrForObjectDetection](/docs/transformers/v5.23.0/fr/model_doc/detr#transformers.DetrForObjectDetection) en boîtes englobantes finales au format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Prend uniquement en charge PyTorch.

## RTDetrModel[[transformers.RTDetrModel]]

#### transformers.RTDetrModel[[transformers.RTDetrModel]]

```python
transformers.RTDetrModel(config: RTDetrConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr.py#L1424)

**Paramètres :**

config ([RTDetrConfig](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle RT-DETR (composé d'un backbone et d'un encodeur-décodeur) produisant des états cachés bruts sans aucune tête au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.RTDetrModel.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr.py#L1544)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de `image_processor_class`. Consultez `image_processor_class.__call__` pour plus de détails (`processor_class` utilise `image_processor_class` pour le traitement des images).

pixel_mask (`torch.LongTensor` de forme `(batch_size, height, width)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont comprises dans `[0, 1]` : - 1 pour les pixels réels (c.-à-d. **non masqués**), - 0 pour les pixels de bourrage (c.-à-d. **masqués**). [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

encoder_outputs (`torch.Tensor`, *facultatif*) : Tuple composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer la carte de caractéristiques aplatie (sortie du backbone + couche de projection), vous pouvez choisir de passer directement une représentation aplatie d'une image.

labels (`list[Dict]` de longueur `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de correspondance bipartite. Liste de dictionnaires, chaque dictionnaire contenant au moins les 2 clés suivantes : 'class_labels' et 'boxes' (les étiquettes de classes et les boîtes englobantes d'une image du lot, respectivement). Les étiquettes de classes elles-mêmes doivent être un `torch.LongTensor` de longueur `(number of bounding boxes in the image,)` et les boîtes un `torch.Tensor` de forme `(number of bounding boxes in the image, 4)`.

**Retourne :** `RTDetrModelOutput` ou `tuple(torch.Tensor)`

Un `RTDetrModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration (`None`) et les entrées.

La méthode forward de [RTDetrModel](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_queries, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.
- **intermediate_hidden_states** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- États cachés intermédiaires empilés (sortie de chaque couche du décodeur).
- **intermediate_logits** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, sequence_length, config.num_labels)`) -- Logits intermédiares empilés (logits de chaque couche du décodeur).
- **intermediate_reference_points** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Points de référence intermédiaires empilés (points de référence de chaque couche du décodeur).
- **intermediate_predicted_corners** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Coins intermédiaires prédits empilés (coins prédits de chaque couche du décodeur).
- **initial_reference_points** (`torch.Tensor` de forme `(batch_size, num_queries, 4)`) -- Points de référence initiaux utilisés pour la première couche du décodeur.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **init_reference_points** (`torch.Tensor` de forme `(batch_size, num_queries, 4)`) -- Points de référence initiaux transmis au décodeur du Transformer.
- **enc_topk_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) -- Scores des boîtes englobantes prédites, où les `config.two_stage_num_proposals` boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions à l'étape de l'encodeur. Sortie de la classification binaire des boîtes englobantes (c'est-à-dire premier plan et arrière-plan).
- **enc_topk_bboxes** (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`) -- Logits des coordonnées des boîtes englobantes prédites à l'étape de l'encodeur.
- **enc_outputs_class** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Scores des boîtes englobantes prédites, où les `config.two_stage_num_proposals` boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions à la première étape. Sortie de la classification binaire des boîtes englobantes (c.-à-d. premier plan et arrière-plan).
- **enc_outputs_coord_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Logits des coordonnées des boîtes englobantes prédites à la première étape.
- **denoising_meta_values** (`dict`, *facultatif*) -- Dictionnaire supplémentaire pour les valeurs liées au débruitage.

Exemples :

```python
>>> from transformers import AutoImageProcessor, RTDetrModel
>>> 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("PekingU/rtdetr_r50vd")
>>> model = RTDetrModel.from_pretrained("PekingU/rtdetr_r50vd")

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

>>> outputs = model(**inputs)

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

## RTDetrForObjectDetection[[transformers.RTDetrForObjectDetection]]

#### transformers.RTDetrForObjectDetection[[transformers.RTDetrForObjectDetection]]

```python
transformers.RTDetrForObjectDetection(config: RTDetrConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr.py#L1750)

**Paramètres :**

config ([RTDetrConfig](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle RT-DETR (composé d'un backbone et d'un encodeur-décodeur) produisant des boîtes englobantes et des logits à décoder ensuite en scores et en classes.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.RTDetrForObjectDetection.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr.py#L1771)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de `image_processor_class`. Consultez `image_processor_class.__call__` pour plus de détails (`processor_class` utilise `image_processor_class` pour le traitement des images).

pixel_mask (`torch.LongTensor` de forme `(batch_size, height, width)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont comprises dans `[0, 1]` : - 1 pour les pixels réels (c.-à-d. **non masqués**), - 0 pour les pixels de bourrage (c.-à-d. **masqués**). [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

encoder_outputs (`torch.Tensor`, *facultatif*) : Tuple composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer la carte de caractéristiques aplatie (sortie du backbone + couche de projection), vous pouvez choisir de passer directement une représentation aplatie d'une image.

labels (`list[Dict]` de longueur `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de correspondance bipartite. Liste de dictionnaires, chaque dictionnaire contenant au moins les 2 clés suivantes : 'class_labels' et 'boxes' (les étiquettes de classes et les boîtes englobantes d'une image du lot, respectivement). Les étiquettes de classes elles-mêmes doivent être un `torch.LongTensor` de longueur `(number of bounding boxes in the image,)` et les boîtes un `torch.Tensor` de forme `(number of bounding boxes in the image, 4)`.

**Retourne :** `RTDetrObjectDetectionOutput` ou `tuple(torch.Tensor)`

Un `RTDetrObjectDetectionOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration (`None`) et les entrées.

La méthode forward de [RTDetrForObjectDetection](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrForObjectDetection) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni)) -- Perte totale en tant que combinaison linéaire d'une négation de la log-vraisemblance (entropie croisée) pour la prédiction de classe et d'une perte de boîte englobante. Cette dernière est définie comme une combinaison linéaire de la perte L1 et de la perte d'IoU généralisée insensible à l'échelle.
- **loss_dict** (`Dict`, *facultatif*) -- Un dictionnaire contenant les pertes individuelles. Utile pour la journalisation.
- **logits** (`torch.Tensor` de forme `(batch_size, num_queries, num_classes + 1)`) -- Logits de classification (y compris no-object) pour toutes les requêtes.
- **pred_boxes** (`torch.Tensor` de forme `(batch_size, num_queries, 4)`) -- Coordonnées des boîtes normalisées pour toutes les requêtes, représentées sous la forme (center_x, center_y, width, height). Ces valeurs sont normalisées dans [0, 1], par rapport à la taille de chaque image individuelle du lot (en ignorant tout padding éventuel). Vous pouvez utiliser [post_process_object_detection()](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrImageProcessor.post_process_object_detection) pour récupérer les boîtes englobantes non normalisées (absolues).
- **auxiliary_outputs** (`list[Dict]`, *facultatif*) -- Facultatif, renvoyé uniquement lorsque les pertes auxiliaires sont activées (c.-à-d. `config.auxiliary_loss` est défini sur `True`) et que des étiquettes sont fournies. C'est une liste de dictionnaires contenant les deux clés ci-dessus (`logits` et `pred_boxes`) pour chaque couche du décodeur.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_queries, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.
- **intermediate_hidden_states** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- États cachés intermédiaires empilés (sortie de chaque couche du décodeur).
- **intermediate_logits** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, config.num_labels)`) -- Logits intermédiares empilés (logits de chaque couche du décodeur).
- **intermediate_reference_points** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Points de référence intermédiaires empilés (points de référence de chaque couche du décodeur).
- **intermediate_predicted_corners** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Coins intermédiaires prédits empilés (coins prédits de chaque couche du décodeur).
- **initial_reference_points** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Points de référence initiaux empilés (points de référence initiaux de chaque couche du décodeur).
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **init_reference_points** (`torch.Tensor` de forme  `(batch_size, num_queries, 4)`) -- Points de référence initiaux transmis au décodeur du Transformer.
- **enc_topk_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Logits des coordonnées des boîtes englobantes prédites dans l'encodeur.
- **enc_topk_bboxes** (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Logits des coordonnées des boîtes englobantes prédites dans l'encodeur.
- **enc_outputs_class** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Scores des boîtes englobantes prédites, où les `config.two_stage_num_proposals` boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions à la première étape. Sortie de la classification binaire des boîtes englobantes (c.-à-d. premier plan et arrière-plan).
- **enc_outputs_coord_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Logits des coordonnées des boîtes englobantes prédites à la première étape.
- **denoising_meta_values** (`dict`, *facultatif*) -- Dictionnaire supplémentaire pour les valeurs liées au débruitage

Exemples :

```python
>>> from transformers import RTDetrImageProcessor, RTDetrForObjectDetection
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch

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

>>> image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
>>> model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd")

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

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

>>> logits = outputs.logits
>>> list(logits.shape)
[1, 300, 80]

>>> boxes = outputs.pred_boxes
>>> list(boxes.shape)
[1, 300, 4]

>>> # 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 sofa with confidence 0.97 at location [0.14, 0.38, 640.13, 476.21]
Detected cat with confidence 0.96 at location [343.38, 24.28, 640.14, 371.5]
Detected cat with confidence 0.958 at location [13.23, 54.18, 318.98, 472.22]
Detected remote with confidence 0.951 at location [40.11, 73.44, 175.96, 118.48]
Detected remote with confidence 0.924 at location [333.73, 76.58, 369.97, 186.99]
```

## RTDetrResNetBackbone[[transformers.RTDetrResNetBackbone]]

#### transformers.RTDetrResNetBackbone[[transformers.RTDetrResNetBackbone]]

```python
transformers.RTDetrResNetBackbone(config: RTDetrResNetConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr_resnet.py#L349)

**Paramètres :**

config ([RTDetrResNetConfig](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrResNetConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Backbone ResNet, à utiliser avec des frameworks comme RTDETR.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.RTDetrResNetBackbone.forward]]

```python
forward(pixel_values: Tensor, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr/modeling_rt_detr_resnet.py#L362)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de `image_processor_class`. Consultez `image_processor_class.__call__` pour plus de détails (`processor_class` utilise `image_processor_class` pour le traitement des images).

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** `BackboneOutput` ou `tuple(torch.Tensor)`

Un `BackboneOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([RTDetrResNetConfig](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrResNetConfig)) et les entrées.

La méthode forward de [RTDetrResNetBackbone](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrResNetBackbone) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **feature_maps** (`tuple(torch.Tensor)` de forme `(batch_size, num_channels, height, width)`) -- Cartes de caractéristiques des étapes.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)` ou `(batch_size, num_channels, height, width)`, selon le backbone.

  États cachés du modèle à la sortie de chaque étape, ainsi que les sorties des embeddings initiaux.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Applicable uniquement si le backbone utilise l'attention.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  Exemples :

  ```python
  >>> from transformers import RTDetrResNetConfig, RTDetrResNetBackbone
  >>> import torch
  precation import deprecate_kwarg
  precation import deprecate_kwarg
  precation import deprecate_kwarg
  utils.deprecation import deprecate_kwarg
  utils.deprecation import deprecate_kwarg

  >>> config = RTDetrResNetConfig()
  >>> model = RTDetrResNetBackbone(config)

  >>> pixel_values = torch.randn(1, 3, 224, 224)

  >>> with torch.no_grad():
  ...     outputs = model(pixel_values)

  >>> feature_maps = outputs.feature_maps
  >>> list(feature_maps[-1].shape)
  [1, 2048, 7, 7]
  ```

