# DEIMv2

## Aperçu

DEIMv2 (DETR with Improved Matching v2) a été proposé dans [DEIMv2: Real-Time Object Detection Meets DINOv3](https://huggingface.co/papers/2509.20787) par Shihua Huang, Yongjie Hou, Longfei Liu, Xuanlong Yu et Xi Shen.

L'abstract de l'article est le suivant :

*Grâce au Dense O2O simple et efficace, DEIM présente une convergence plus rapide et des performances améliorées. Dans ce travail, nous l'étendons avec les caractéristiques DINOv3, ce qui donne DEIMv2. DEIMv2 couvre huit tailles de modèles, de X à Atto, pour un déploiement sur GPU, sur edge et sur mobile. Pour les variantes X, L, M et S, nous adoptons des backbones pré-entraînés ou distillés avec DINOv3 et introduisons un Spatial Tuning Adapter (STA), qui convertit efficacement la sortie mono-échelle de DINOv3 en caractéristiques multi-échelles et complète les sémantiques fortes avec des détails fins pour améliorer la détection. Pour les modèles ultra-légers (Nano, Pico, Femto et Atto), nous utilisons HGNetv2 avec élagage de la profondeur et de la largeur pour respecter des budgets de ressources stricts. Associé à un décodeur simplifié et à un Dense O2O amélioré, cette conception unifiée permet à DEIMv2 d'atteindre un compromis performance-coût supérieur dans divers scénarios, établissant de nouveaux résultats de l'état de l'art. Notamment, notre plus grand modèle, DEIMv2-X, atteint 57,8 AP avec seulement 50,3M de paramètres, dépassant les modèles X-scale antérieurs qui nécessitent plus de 60M de paramètres pour seulement 56,5 AP. Côté compact, DEIMv2-S est le premier modèle de moins de 10M (9,71M) à dépasser le jalon des 50 AP sur COCO, atteignant 50,9 AP. Même le DEIMv2-Pico ultra-léger, avec seulement 1,5M de paramètres, délivre 38,5 AP, égalant YOLOv10-Nano (2,3M) avec environ 50 % de paramètres en moins.*

Ce modèle a été contribué par [Harshal Janjani](https://huggingface.co/harshaljanjani). Le code d’origine est disponible [ici](https://github.com/Intellindust-AI-Lab/DEIMv2).

## Utilisation

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from transformers.image_utils import load_image

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = load_image(url)

image_processor = AutoImageProcessor.from_pretrained("harshaljanjani/DEIMv2_HGNetv2_N_COCO_Transformers")
model = AutoModelForObjectDetection.from_pretrained("harshaljanjani/DEIMv2_HGNetv2_N_COCO_Transformers", device_map="auto")

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

results = image_processor.post_process_object_detection(
    outputs, threshold=0.5, target_sizes=[image.size[::-1]]
)

for result in results:
    for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
        box = [round(i, 2) for i in box.tolist()]
        print(f"Detected {model.config.id2label[label.item()]} with confidence {round(score.item(), 3)} at location {box}")
```

## Deimv2Config[[transformers.Deimv2Config]]

#### transformers.Deimv2Config[[transformers.Deimv2Config]]

```python
transformers.Deimv2Config(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: list[int] | tuple[int, 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 | list[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, weight_loss_fgl: float = 0.15, weight_loss_ddf: float = 1.5, eos_coefficient: float = 0.0001, eval_idx: int = -1, layer_scale: int | float = 1.0, max_num_bins: int = 32, reg_scale: float = 4.0, depth_mult: float = 1.0, top_prob_values: int = 4, lqe_hidden_dim: int = 64, lqe_layers: int = 2, decoder_offset_scale: float = 0.5, decoder_method: str = 'default', up: float = 0.5, tie_word_embeddings: bool = True, weight_loss_mal: float = 1.0, use_dense_one_to_one: bool = True, mal_alpha: float | None = None, encoder_fuse_op: str = 'sum', spatial_tuning_adapter_inplanes: int = 16, encoder_type: str = 'hybrid', use_gateway: bool = True, share_bbox_head: bool = False, encoder_has_trailing_conv: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deimv2/configuration_deimv2.py#L32)

**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*, valeur par défaut `"gelu"`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) utilisée dans l'encodeur et le pooler.

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 (`list[int]` ou `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"`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur.

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*, valeur 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.

with_box_refine (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut appliquer un raffinement itératif des boîtes englobantes.

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.

weight_loss_fgl (`float`, *facultatif*, valeur par défaut 0.15) : Poids relatif de la perte de localisation fine dans la perte de détection d'objets.

weight_loss_ddf (`float`, *facultatif*, valeur par défaut 1,5) : Poids relatif de la perte focale de distillation découplé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.

eval_idx (`int`, *facultatif*, valeur par défaut : -1) : Index de la couche du décodeur à utiliser pour l'évaluation.

layer_scale (`float`, *facultatif*, par défaut `1.0`) : Facteur d'échelle pour la dimension cachée dans les couches de décodeur ultérieures.

max_num_bins (`int`, *facultatif*, valeur par défaut : 32) : Nombre maximal de bins pour le raffinement des boîtes englobantes guidé par la distribution.

reg_scale (`float`, *facultatif*, valeur par défaut 4.0) : Facteur d'échelle pour la distribution de régression.

depth_mult (`float`, *facultatif*, valeur par défaut 1.0) : Multiplicateur du nombre de blocs dans les couches RepNCSPELAN5.

top_prob_values (`int`, *facultatif*, valeur par défaut : 4) : Nombre de valeurs de probabilité les plus élevées à prendre en compte dans la distribution de chaque coin.

lqe_hidden_dim (`int`, *facultatif*, valeur par défaut : 64) : Taille de la dimension cachée pour le réseau Location Quality Estimator (LQE).

lqe_layers (`int`, *facultatif*, valeur par défaut : 2) : Nombre de couches du MLP de l'estimateur de qualité de localisation.

decoder_offset_scale (`float`, *facultatif*, valeur par défaut 0,5) : Échelle de décalage utilisée dans l'attention déformable.

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

up (`float`, *facultatif*, valeur par défaut 0,5) : Contrôle les bornes supérieures de la fonction de pondération.

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.

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

use_dense_one_to_one (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un appariement dense un-à-un entre les couches du décodeur.

mal_alpha (`float`, *facultatif*) : Paramètre alpha pour la Matching Auxiliary Loss (MAL). Si `None`, utilise `focal_loss_alpha`.

encoder_fuse_op (`str`, *facultatif*, valeur par défaut `"sum"`) : Opération de fusion utilisée dans le FPN de l'encodeur. DEIMv2 utilise `"sum"` au lieu de `"cat"` de D-FINE.

spatial_tuning_adapter_inplanes (`int`, *facultatif*, valeur par défaut 16) : Nombre de plans d'entrée pour la tige convolutive STA.

encoder_type (`str`, *facultatif*, valeur par défaut `"hybrid"`) : Type d'encodeur à utiliser. `"hybrid"` utilise l'encodeur complet HybridEncoder avec AIFI, FPN et PAN. `"lite"` utilise l'encodeur léger LiteEncoder avec fusion GAP pour les variantes plus petites (Atto, Femto, Pico).

use_gateway (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser le mécanisme de passerelle (gating de l'attention croisée) dans les couches décodeur. Si `False`, utilise RMSNorm sur la sortie de l'attention encodeur à la place.

share_bbox_head (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut partager la tête de prédiction des boîtes englobantes entre toutes les couches du décodeur.

encoder_has_trailing_conv (`bool`, *facultatif*, valeur par défaut `True`) : Indique si les blocs CSP de l'encodeur incluent une convolution 3x3 finale après le chemin de goulot d'étranglement. `True` pour RepNCSPELAN4 (utilisé par les variantes HGNetV2 N et LiteEncoder). `False` pour RepNCSPELAN5 (utilisé par les variantes DINOv3).

Ceci est la classe de configuration destinée à stocker la configuration d'un Deimv2Model. Elle est utilisée pour instancier un modèle Deimv2 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 [Intellindust/DEIMv2_HGNetv2_N_COCO](https://huggingface.co/Intellindust/DEIMv2_HGNetv2_N_COCO)

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.

## Deimv2Model[[transformers.Deimv2Model]]

#### transformers.Deimv2Model[[transformers.Deimv2Model]]

```python
transformers.Deimv2Model(config: Deimv2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deimv2/modeling_deimv2.py#L1695)

**Paramètres :**

config ([Deimv2Config](/docs/transformers/v5.23.0/fr/model_doc/deimv2#transformers.Deimv2Config)) : 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.Deimv2Model.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/deimv2/modeling_deimv2.py#L1789)

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

Un `Deimv2ModelOutput` 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 [Deimv2Model](/docs/transformers/v5.23.0/fr/model_doc/deimv2#transformers.Deimv2Model) surcharge 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, Deimv2Model
>>> 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/Deimv2_r50vd")
>>> model = Deimv2Model.from_pretrained("PekingU/Deimv2_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]
```

## Deimv2ForObjectDetection[[transformers.Deimv2ForObjectDetection]]

#### transformers.Deimv2ForObjectDetection[[transformers.Deimv2ForObjectDetection]]

```python
transformers.Deimv2ForObjectDetection(config: Deimv2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deimv2/modeling_deimv2.py#L2068)

**Paramètres :**

config ([Deimv2Config](/docs/transformers/v5.23.0/fr/model_doc/deimv2#transformers.Deimv2Config)) : 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.Deimv2ForObjectDetection.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/deimv2/modeling_deimv2.py#L2107)

**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 `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

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

Un `Deimv2ObjectDetectionOutput` 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 [Deimv2ForObjectDetection](/docs/transformers/v5.23.0/fr/model_doc/deimv2#transformers.Deimv2ForObjectDetection) 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 `~Deimv2ImageProcessor.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

Exemple :

```python
>>> import torch
>>> from transformers.image_utils import load_image
>>> from transformers import AutoImageProcessor, Deimv2ForObjectDetection

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = load_image(url)

>>> image_processor = AutoImageProcessor.from_pretrained("harshaljanjani/DEIMv2_HGNetv2_N_COCO_Transformers")
>>> model = Deimv2ForObjectDetection.from_pretrained("harshaljanjani/DEIMv2_HGNetv2_N_COCO_Transformers")

>>> # 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)
>>> result = results[0]  # first image in batch

>>> for score, label, box in zip(result["scores"], result["labels"], result["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}"
...     )
```

