# RT-DETRv2

## Aperçu

Le modèle RT-DETRv2 a été proposé dans [RT-DETRv2: Improved Baseline with Bag-of-Freebies for Real-Time Detection Transformer](https://huggingface.co/papers/2407.17140) par Wenyu Lv, Yian Zhao, Qinyao Chang, Kui Huang, Guanzhong Wang, Yi Liu.

RT-DETRv2 affine RT-DETR en introduisant une extraction sélective de caractéristiques multi-échelles, un opérateur d'échantillonnage discret pour une compatibilité d'implémentation plus large, et des stratégies d'entraînement améliorées telles que l'augmentation dynamique des données et des hyperparamètres adaptatifs à l'échelle. Ces modifications renforcent la flexibilité et la praticité tout en maintenant des performances en temps réel.

L'abstract de l'article est le suivant :

*Dans ce rapport, nous présentons RT-DETRv2, une version améliorée du Real-Time DEtection TRansformer (RT-DETR). RT-DETRv2 s’appuie sur le détecteur temps réel de l’état de l’art précédent, RT-DETR, et ouvre la voie à un ensemble de « bag-of-freebies » pour la flexibilité et la praticité, tout en optimisant la stratégie d’entraînement afin d’obtenir des performances accrues. Pour améliorer la flexibilité, nous proposons de définir un nombre distinct de points d’échantillonnage pour les caractéristiques à différentes échelles dans l’attention déformable, afin de réaliser une extraction sélective de caractéristiques multi-échelles par le décodeur. Pour renforcer la praticité, nous proposons un opérateur d’échantillonnage discret facultatif pour remplacer l’opérateur grid_sample, spécifique à RT-DETR par rapport aux YOLOs. Cela supprime les contraintes de déploiement généralement associées aux DETRs. Concernant la stratégie d’entraînement, nous proposons une augmentation dynamique des données et une personnalisation d’hyperparamètres adaptative à l’échelle pour améliorer les performances sans perte de vitesse.*

Ce modèle a été contribué par [jadechoghari](https://huggingface.co/jadechoghari). Le code d'origine peut être trouvé [ici](https://github.com/lyuwenyu/RT-DETR).

## Conseils d'utilisation

Cette deuxième version de RT-DETR améliore la manière dont le décodeur localise les objets dans une image.

- **échantillonnage amélioré** – ajuste les décalages pour que le modèle observe les zones appropriées
- **flexible attention** – peut utiliser un échantillonnage lisse (bilinéaire) ou fixe (discrét)
- **traitement optimisé** – améliore la façon dont les poids d'attention mélangent les informations

Le modèle est conçu pour être utilisé sur des images redimensionnées à la taille 640x640 à l'aide de 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 RTDetrImageProcessor, RTDetrV2ForObjectDetection

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

image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_v2_r18vd")
model = RTDetrV2ForObjectDetection.from_pretrained("PekingU/rtdetr_v2_r18vd", 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.5)

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}")
cat: 0.97 [341.14, 25.11, 639.98, 372.89]
cat: 0.96 [12.78, 56.35, 317.67, 471.34]
remote: 0.95 [39.96, 73.12, 175.65, 117.44]
sofa: 0.86 [-0.11, 2.97, 639.89, 473.62]
sofa: 0.82 [-0.12, 1.78, 639.87, 473.52]
remote: 0.79 [333.65, 76.38, 370.69, 187.48]
```

## Ressources

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

- Voir aussi : [Guide de la tâche de détection d'objets](../tasks/object_detection).
- Notebooks pour l'[inférence](https://github.com/qubvel/transformers-notebooks/blob/main/notebooks/RT_DETR_v2_inference.ipynb) et le [fine-tuning](https://github.com/qubvel/transformers-notebooks/blob/main/notebooks/RT_DETR_v2_finetune_on_a_custom_dataset.ipynb) de RT-DETRv2 sur un jeu de données personnalisé (🌎).

## RTDetrV2Config[[transformers.RTDetrV2Config]]

#### transformers.RTDetrV2Config[[transformers.RTDetrV2Config]]

```python
transformers.RTDetrV2Config(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, 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, decoder_n_levels: int = 3, decoder_offset_scale: float = 0.5, decoder_method: str = 'default', tie_word_embeddings: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr_v2/configuration_rt_detr_v2.py#L29)

**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) de la couche générale. Si c'est une chaîne de caractères, `"gelu"`, `"relu"`, `"silu"` et `"gelu_new"` sont pris en charge.

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.

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.

decoder_n_levels (`int`, *facultatif*, valeur par défaut : 3) : Le nombre de niveaux de caractéristiques utilisés par le décodeur.

decoder_offset_scale (`float`, *facultatif*, valeur par défaut 0,5) : Facteur d'échelle appliqué aux décalages d'attention dans le décodeur.

decoder_method (`str`, *facultatif*, par défaut `"default"`) : La méthode à utiliser pour le décodeur : `"default"` ou `"discrete"`.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un RTDetrV2Model. Elle est utilisée pour instancier un modèle Rt Detr V2 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_r18vd](https://huggingface.co/PekingU/rtdetr_r18vd)

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 RTDetrV2Config, RTDetrV2Model

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

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

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

## RTDetrV2Model[[transformers.RTDetrV2Model]]

#### transformers.RTDetrV2Model[[transformers.RTDetrV2Model]]

```python
transformers.RTDetrV2Model(config: RTDetrV2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr_v2/modeling_rt_detr_v2.py#L1343)

**Paramètres :**

config ([RTDetrV2Config](/docs/transformers/v5.23.0/fr/model_doc/rt_detr_v2#transformers.RTDetrV2Config)) : 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.RTDetrV2Model.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_v2/modeling_rt_detr_v2.py#L1462)

**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 :** `RTDetrV2ModelOutput` ou `tuple(torch.Tensor)`

Un `RTDetrV2ModelOutput` 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 du modèle [RTDetrV2Model](/docs/transformers/v5.23.0/fr/model_doc/rt_detr_v2#transformers.RTDetrV2Model) 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, RTDetrV2Model
>>> 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/RTDetrV2_r50vd")
>>> model = RTDetrV2Model.from_pretrained("PekingU/RTDetrV2_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]
```

## RTDetrV2ForObjectDetection[[transformers.RTDetrV2ForObjectDetection]]

#### transformers.RTDetrV2ForObjectDetection[[transformers.RTDetrV2ForObjectDetection]]

```python
transformers.RTDetrV2ForObjectDetection(config: RTDetrV2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/rt_detr_v2/modeling_rt_detr_v2.py#L1765)

**Paramètres :**

config ([RTDetrV2Config](/docs/transformers/v5.23.0/fr/model_doc/rt_detr_v2#transformers.RTDetrV2Config)) : 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.RTDetrV2ForObjectDetection.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_v2/modeling_rt_detr_v2.py#L1798)

**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 :** `RTDetrV2ObjectDetectionOutput` ou `tuple(torch.Tensor)`

Un `RTDetrV2ObjectDetectionOutput` 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 [RTDetrV2ForObjectDetection](/docs/transformers/v5.23.0/fr/model_doc/rt_detr_v2#transformers.RTDetrV2ForObjectDetection) 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 `~RTDetrV2ImageProcessor.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 RTDetrV2ImageProcessor, RTDetrV2ForObjectDetection
>>> 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 = RTDetrV2ImageProcessor.from_pretrained("PekingU/RTDetrV2_r50vd")
>>> model = RTDetrV2ForObjectDetection.from_pretrained("PekingU/RTDetrV2_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]
```

