# LW-DETR

[LW-DETR](https://huggingface.co/papers/2407.17140) propose une architecture de Detection Transformer (DETR) légère, conçue pour rivaliser avec et dépasser la série dominante YOLO pour la détection d'objets en temps réel. Elle atteint un nouvel équilibre de pointe entre la vitesse (latence) et la précision (mAP) en combinant les avancées récentes des transformers avec des choix de conception efficaces.

L'architecture LW-DETR se caractérise par sa structure simple et efficace : un encodeur ViT standard, un Projector et un décodeur DETR peu profond. Elle améliore l'architecture DETR en termes d'efficacité et de rapidité grâce aux modifications fondamentales suivantes :
1. Encodeur ViT efficace : utilise un ViT simple avec une attention fenêtre/global alternée et une organisation par fenêtre principale pour réduire considérablement la complexité et la latence de l'attention.
2. Entrée plus riche : agrège des caractéristiques multi-niveaux issues de l'encodeur et utilise un projecteur C2f (YOLOv8) pour transmettre des caractéristiques à deux échelles ($1/8$ et $1/32$).
3. Décodeur plus rapide : Utilise un décodeur DETR peu profond de 3 couches avec une attention croisée déformable pour une latence réduite et une convergence plus rapide.
4. Requêtes optimisées : utilise un schéma de requêtes mixtes combinant des requêtes de contenu apprenables et des requêtes spatiales générées.

Vous pouvez trouver tous les points de contrôle LW DETR disponibles sous l’organisation [AnnaZhang](https://huggingface.co/AnnaZhang). Le code d’origine est disponible [ici](https://github.com/Atten4Vis/LW-DETR).

> [!TIP]
> Ce modèle a été contribué par [stevenbucaille](https://huggingface.co/stevenbucaille).
>
> Cliquez sur les modèles LW-DETR dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer LW-DETR à différentes tâches de détection d’objets.

L'exemple ci-dessous montre comment effectuer la détection d'objets avec le [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline) et la classe [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel).

```python

from transformers import pipeline

pipeline = pipeline(
    "object-detection",
    model="AnnaZhang/lwdetr_small_60e_coco",
    device_map=0
)

pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")
```

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

from transformers import AutoImageProcessor, AutoModelForObjectDetection

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

image_processor = AutoImageProcessor.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
model = AutoModelForObjectDetection.from_pretrained("AnnaZhang/lwdetr_small_60e_coco", device_map="auto")

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

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

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

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

## Ressources

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

- Voir aussi : [Guide de la tâche de détection d'objets](../tasks/object_detection).

## LwDetrConfig[[transformers.LwDetrConfig]]

#### transformers.LwDetrConfig[[transformers.LwDetrConfig]]

```python
transformers.LwDetrConfig(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, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projector_scale_factors: list[float] | tuple[float, ...] = (), hidden_expansion: float = 0.5, c2f_num_blocks: int = 3, activation_function: str = 'silu', batch_norm_eps: float = 1e-05, dropout: float | int = 0.0, decoder_ffn_dim: int = 2048, decoder_n_points: int = 4, decoder_layers: int = 3, decoder_self_attention_heads: int = 8, decoder_cross_attention_heads: int = 16, decoder_activation_function: str = 'relu', num_queries: int = 300, attention_bias: bool = True, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, group_detr: int = 13, init_std: float = 0.02, disable_custom_kernels: bool = True, class_cost: int | float = 2, bbox_cost: int | float = 5, giou_cost: int | float = 2, class_loss_coefficient: int | float = 1, dice_loss_coefficient: int | float = 1, bbox_loss_coefficient: int | float = 5, giou_loss_coefficient: int | float = 2, eos_coefficient: float = 0.1, focal_alpha: float = 0.25, auxiliary_loss: bool = True, d_model: int = 256)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/configuration_lw_detr.py#L109)

**Paramètres :**

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

projector_scale_factors (`list[float]`, *facultatif*, valeur par défaut `[]`) : Facteurs d'échelle pour le réseau de pyramide de caractéristiques. Chaque facteur d'échelle détermine la résolution des caractéristiques aux différents niveaux. Les valeurs prises en charge sont 0,5, 1,0 et 2,0.

hidden_expansion (`float`, *facultatif*, valeur par défaut 0,5) : Facteur d'expansion des dimensions cachées dans les couches projecteur.

c2f_num_blocks (`int`, *facultatif*, valeur par défaut : 3) : Nombre de blocs dans la couche C2F.

activation_function (`str`, *facultatif*, valeur par défaut `"silu"`) : Fonction d'activation non linéaire du projecteur. Les valeurs prises en charge sont `"silu"`, `"relu"`, `"gelu"`.

batch_norm_eps (`float`, *facultatif*, valeur par défaut 1e-05) : La valeur epsilon pour les couches de normalisation par lot.

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

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

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 `3`) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

decoder_self_attention_heads (`int`, *facultatif*, valeur par défaut : 8) : Nombre de têtes d'attention pour chaque couche d'attention dans l'auto-attention du décodeur.

decoder_cross_attention_heads (`int`, *facultatif*, valeur par défaut : 16) : Nombre de têtes d'attention pour chaque couche d'attention croisée du décodeur.

decoder_activation_function (`str`, *facultatif*, valeur par défaut `"relu"`) : Fonction d'activation non linéaire du décodeur. Les valeurs prises en charge sont `"relu"`, `"silu"`, `"gelu"`.

num_queries (`int`, *facultatif*, valeur par défaut : 300) : Nombre de requêtes d'objets, c'est-à-dire de slots de détection. C'est le nombre maximal d'objets que [LwDetrModel](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrModel) peut détecter dans une image unique.

attention_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention.

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

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.

group_detr (`int`, *facultatif*, valeur par défaut 13) : Nombre de groupes pour le mécanisme d'attention Group DETR, qui aide à réduire la complexité de calcul.

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

disable_custom_kernels (`bool`, *facultatif*, valeur par défaut `True`) : Désactive l'utilisation de noyaux CUDA et CPU personnalisés. Cette option est nécessaire pour l'export ONNX, car les noyaux personnalisés ne sont pas pris en charge par l'export ONNX de PyTorch.

class_cost (`Union[int, float]`, *facultatif*, valeur par défaut `2`) : Poids relatif de l'erreur de classification dans le coût d'appariement hongrois.

bbox_cost (`Union[int, float]`, *facultatif*, valeur par défaut `5`) : Poids relatif de l'erreur de boîte englobante L1 dans le coût d'appariement hongrois.

giou_cost (`Union[int, float]`, *facultatif*, valeur par défaut `2`) : Poids relatif de la perte d'IoU généralisée dans le coût d'appariement hongrois.

class_loss_coefficient (`float`, *facultatif*, valeur par défaut 1) : Poids relatif de la perte de classification dans le coût d'appariement hongrois.

dice_loss_coefficient (`Union[int, float]`, *facultatif*, valeur par défaut `1`) : Poids relatif de la perte dice dans la perte de segmentation panoptique.

bbox_loss_coefficient (`Union[int, float]`, *facultatif*, valeur par défaut `5`) : Poids relatif de la perte de boîte englobante L1 dans la perte de segmentation panoptique.

giou_loss_coefficient (`Union[int, float]`, *facultatif*, valeur par défaut `2`) : Poids relatif de la perte d'IoU généralisée dans la perte de segmentation panoptique.

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

focal_alpha (`float`, *facultatif*, valeur par défaut `0.25`) : Paramètre alpha de la focal loss.

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.

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

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

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/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/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemples :

```python
>>> from transformers import LwDetrConfig, LwDetrModel

>>> # Initializing a LW-DETR AnnaZhang/lwdetr_small_60e_coco style configuration
>>> configuration = LwDetrConfig()

>>> # Initializing a model (with random weights) from the AnnaZhang/lwdetr_small_60e_coco style configuration
>>> model = LwDetrModel(configuration)

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

## LwDetrViTConfig[[transformers.LwDetrViTConfig]]

#### transformers.LwDetrViTConfig[[transformers.LwDetrViTConfig]]

```python
transformers.LwDetrViTConfig(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, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, mlp_ratio: int = 4, hidden_act: str = 'gelu', dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 256, pretrain_image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True, window_block_indices: list[int] | tuple[int, ...] = (), use_absolute_position_embeddings: bool = True, _out_features: list[str] | None = None, _out_indices: list[int] | None = None, cae_init_values: float = 0.1, num_windows: int = 16)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/configuration_lw_detr.py#L35)

**Paramètres :**

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

num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer.

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

mlp_ratio (`int`, *facultatif*, par défaut `4`) : Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding.

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

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

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

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

image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `256`) : La taille (résolution) de chaque image.

pretrain_image_size (`int`, *facultatif*, par défaut 224) : La taille (résolution) de chaque image lors de la préformation.

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `16`) : La taille (résolution) de chaque patch.

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

qkv_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter un biais aux requêtes, clés et valeurs.

window_block_indices (`list[int]`, *facultatif*, valeur par défaut `[]`) : Liste des indices des blocs qui doivent utiliser l'attention de fenêtre au lieu de l'auto-attention globale régulière.

use_absolute_position_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter des embeddings de position absolue aux embeddings de patch.

cae_init_values (`float`, *facultatif*, valeur par défaut 0.1) : Valeur d'initialisation des paramètres CAE lorsque `use_cae` est activé.

num_windows (`int`, *facultatif*, valeur par défaut 16) : Nombre de fenêtres pour l'attention basée sur les fenêtres. Doit être un carré parfait et la taille de l'image doit être divisible par la racine carrée de cette valeur. Cela permet une organisation efficace des cartes de caractéristiques par fenêtre.

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

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/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/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import LwDetrViTConfig, LwDetrViTModel

>>> # Initializing a LW-DETR ViT configuration
>>> configuration = LwDetrViTConfig()

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

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

## LwDetrModel[[transformers.LwDetrModel]]

#### transformers.LwDetrModel[[transformers.LwDetrModel]]

```python
transformers.LwDetrModel(config: LwDetrConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1204)

**Paramètres :**

config ([LwDetrConfig](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle LW Detr brut (composé d’un backbone et d’un Transformer décodeur) qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.LwDetrModel.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1310)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [DeformableDetrImageProcessor](/docs/transformers/main/fr/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Voir [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [DeformableDetrImageProcessor](/docs/transformers/main/fr/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) 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)

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

Un `LwDetrModelOutput` 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 ([LwDetrConfig](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrConfig)) et les entrées.

La méthode forward du modèle [LwDetrModel](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrModel) 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.

- **init_reference_points** (`torch.Tensor` de forme  `(batch_size, num_queries, 4)`) -- Points de référence initiaux transmis au décodeur du Transformer.
- **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 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_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).
- **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.
- **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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **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)`.

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

Exemples :

```python
>>> from transformers import AutoImageProcessor, DeformableDetrModel
>>> 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("AnnaZhang/lwdetr_small_60e_coco")
>>> model = DeformableDetrModel.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")

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

## LwDetrForObjectDetection[[transformers.LwDetrForObjectDetection]]

#### transformers.LwDetrForObjectDetection[[transformers.LwDetrForObjectDetection]]

```python
transformers.LwDetrForObjectDetection(config: LwDetrConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1540)

**Paramètres :**

config ([LwDetrConfig](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle LW DETR (composé d'un backbone et d'un Transformer décodeur) avec des têtes de détection d'objets au sommet, pour des tâches telles que la détection COCO.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.LwDetrForObjectDetection.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L1554)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de [DeformableDetrImageProcessor](/docs/transformers/main/fr/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Voir [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [DeformableDetrImageProcessor](/docs/transformers/main/fr/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) 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)

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

Un `LwDetrObjectDetectionOutput` 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 ([LwDetrConfig](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrConfig)) et les entrées.

La méthode forward de [LwDetrForObjectDetection](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrForObjectDetection) 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 `~DeformableDetrProcessor.post_process_object_detection` pour récupérer les boîtes englobantes non normalisées.
- **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.
- **init_reference_points** (`torch.Tensor` de forme  `(batch_size, num_queries, 4)`) -- Points de référence initiaux transmis au décodeur du Transformer.
- **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 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_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).
- **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.
- **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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **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)`.

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

Exemples :

```python
>>> from transformers import AutoImageProcessor, LwDetrForObjectDetection
>>> 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("AnnaZhang/lwdetr_small_60e_coco")
>>> model = LwDetrForObjectDetection.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")

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

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, 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 cat with confidence 0.8 at location [16.5, 52.84, 318.25, 470.78]
Detected cat with confidence 0.789 at location [342.19, 24.3, 640.02, 372.25]
Detected remote with confidence 0.633 at location [40.79, 72.78, 176.76, 117.25]
```

## LwDetrViTBackbone[[transformers.LwDetrViTBackbone]]

#### transformers.LwDetrViTBackbone[[transformers.LwDetrViTBackbone]]

```python
transformers.LwDetrViTBackbone(config: LwDetrViTConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L342)

**Paramètres :**

config ([LwDetrViTConfig](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrViTConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le backbone de Lw Detr.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/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.LwDetrViTBackbone.forward]]

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lw_detr/modeling_lw_detr.py#L356)

**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 [DeformableDetrImageProcessor](/docs/transformers/main/fr/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor). Voir [DeformableDetrImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [DeformableDetrImageProcessor](/docs/transformers/main/fr/model_doc/deformable_detr#transformers.DeformableDetrImageProcessor) pour le traitement des images).

**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 ([LwDetrConfig](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrConfig)) et les entrées.

La méthode forward de [LwDetrViTBackbone](/docs/transformers/main/fr/model_doc/lw_detr#transformers.LwDetrViTBackbone) 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 LwDetrViTConfig, LwDetrViTBackbone
>>> import torch

>>> config = LwDetrViTConfig()
>>> model = LwDetrViTBackbone(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, 768, 14, 14]
```