# LXMERT

## Aperçu

Le modèle LXMERT a été proposé dans [LXMERT: Learning Cross-Modality Encoder Representations from Transformers](https://huggingface.co/papers/1908.07490) par Hao Tan & Mohit Bansal. Il s’agit d’une série d’encodeurs transformers bidirectionnels (un pour la modalité visuelle, un pour la modalité linguistique, puis un pour fusionner les deux modalités) pré-entraînés à l’aide d’une combinaison d’objectifs de modélisation de langage masqué, d’alignement texte-image, de régression de caractéristiques ROI, de modélisation d’attributs visuels masqués, de modélisation d’objets visuels masqués et de réponse à des questions visuelles. Le pré-entraînement s’appuie sur plusieurs jeux de données multimodaux : MSCOCO, Visual-Genome + Visual-Genome Question Answering, VQA 2.0 et GQA.

L'abstract de l'article est le suivant :

*Le raisonnement visuel et linguistique nécessite une compréhension des concepts visuels, de la sémantique du langage et, surtout, de l'alignement et des relations entre ces deux modalités. Nous proposons donc le cadre LXMERT (Learning Cross-Modality Encoder Representations from Transformers) pour apprendre ces connexions visuelles et linguistiques. Dans LXMERT, nous construisons un grand modèle Transformer composé de trois encodeurs : un encodeur de relations d'objets, un encodeur de langage et un encodeur inter-modalités. Ensuite, pour doter notre modèle de la capacité à relier la sémantique visuelle et linguistique, nous pré-entraînons le modèle avec de grandes quantités de paires d'images et de phrases, via cinq tâches de pré-entraînement diverses et représentatives : le modélage de langage masqué, la prédiction d'objets masqués (régression de caractéristiques et classification d'étiquettes), l'appariement inter-modalités et la réponse à des questions sur des images. Ces tâches aident à apprendre à la fois les relations intra-modalités et inter-modalités. Après un ajustement fin à partir de nos paramètres pré-entraînés, notre modèle atteint des résultats de pointe sur deux jeux de données de réponse à des questions visuelles (à savoir VQA et GQA). Nous montrons également la généralisabilité de notre modèle inter-modalités pré-entraîné en l'adaptant à une tâche de raisonnement visuel exigeante, NLVR, et en améliorant le meilleur résultat précédent de 22 % en absolu (de 54 % à 76 %). Enfin, nous présentons des études d'ablation détaillées pour prouver que nos nouveaux composants de modèle et nos stratégies de pré-entraînement contribuent significativement à nos solides résultats ; nous présentons également plusieurs visualisations d'attention pour les différents encodeurs*

Ce modèle a été contribué par [eltoto1219](https://huggingface.co/eltoto1219). Le code d'origine peut être trouvé [ici](https://github.com/airsplay/lxmert).

## Conseils d'utilisation

- Les boîtes englobantes ne sont pas obligatoires pour être utilisées dans les embeddings de caractéristiques visuelles ; tout type de caractéristiques visuo-spatiales convient.
- Les états cachés du langage et les états cachés visuels que LXMERT produit sont tous deux transmis à travers la couche inter-modalité, ils contiennent donc des informations des deux modalités. Pour accéder à une modalité qui ne porte attention qu'à elle-même, sélectionnez les états cachés vision/langage à partir de la première entrée du tuple.
- L'attention d'encodeur croisé bidirectionnelle ne renvoie des valeurs d'attention que lorsque la modalité langage est utilisée comme entrée et la modalité vision comme vecteur de contexte. De plus, bien que l'encodeur croisé contienne une auto-attention pour chaque modalité respective ainsi qu'une attention croisée, seule l'attention croisée est renvoyée et les deux sorties d'auto-attention sont ignorées.

## Ressources

- [Guide de la tâche de réponse aux questions](../tasks/question_answering)

## LxmertConfig[[transformers.LxmertConfig]]

#### transformers.LxmertConfig[[transformers.LxmertConfig]]

```python
transformers.LxmertConfig(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, vocab_size: int = 30522, hidden_size: int = 768, num_attention_heads: int = 12, num_qa_labels: int = 9500, num_object_labels: int = 1600, num_attr_labels: int = 400, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, l_layers: int = 9, x_layers: int = 5, r_layers: int = 5, visual_feat_dim: int = 2048, visual_pos_dim: int = 4, visual_loss_normalizer: float = 6.67, task_matched: bool = True, task_mask_lm: bool = True, task_obj_predict: bool = True, task_qa: bool = True, visual_obj_loss: bool = True, visual_attr_loss: bool = True, visual_feat_loss: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/configuration_lxmert.py#L24)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `30522`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

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

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.

num_qa_labels (`int`, *facultatif*, valeur par défaut 9500) : représente le nombre total de différentes étiquettes de question-réponse (QA). Si vous utilisez plus d'un jeu de données avec des QA, vous devez prendre en compte le nombre total d'étiquettes présentes dans l'ensemble des jeux de données.

num_object_labels (`int`, *facultatif*, valeur par défaut 1600) : Ce paramètre représente le nombre total d'objets sémantiquement uniques auxquels lxmert peut classer une fonction d'objet agrégé.

num_attr_labels (`int`, *facultatif*, valeur par défaut : 400) : représente le nombre total d'attributs sémantiquement uniques que lxmert peut classifier comme possédés par une fonction d'objet agrégé.

intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP.

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.

hidden_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.

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

max_position_embeddings (`int`, *facultatif*, valeur par défaut `512`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

type_vocab_size (`int`, *facultatif*, par défaut `2`) : La taille du vocabulaire des `token_type_ids`.

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.

l_layers (`int`, *facultatif*, valeur par défaut : 9) : Nombre de couches cachées dans l'encodeur de langage Transformer.

x_layers (`int`, *facultatif*, valeur par défaut : 5) : Nombre de couches cachées dans l'encodeur cross-modality du Transformer.

r_layers (`int`, *facultatif*, valeur par défaut : 5) : Nombre de couches cachées dans l'encodeur visuel Transformer.

visual_feat_dim (`int`, *facultatif*, valeur par défaut : 2048) : Cette valeur représente la dernière dimension des fonctionnalités d'objets regroupés utilisées comme entrée pour le modèle, correspondant à la taille de chaque fonctionnalité d'objet.

visual_pos_dim (`int`, *facultatif*, valeur par défaut : 4) : Ce paramètre représente le nombre de caractéristiques spatiales mélangées aux caractéristiques visuelles. La valeur par défaut est fixée à 4, car cela représente le plus souvent l'emplacement d'une boîte englobante, c'est-à-dire (x, y, largeur, hauteur).

visual_loss_normalizer (`float`, *facultatif*, valeur par défaut : 6.67) : Ce paramètre représente le facteur d'échelle par lequel chaque perte visuelle est multipliée si, lors de la préformation, on a choisi d'entraîner le modèle avec plusieurs objectifs de perte basés sur la vision.

task_matched (`bool`, *facultatif*, valeur par défaut `True`) : Cette tâche est utilisée pour l'association de phrases et d'images. Si la phrase décrit correctement l'image, l'étiquette sera 1. Si la phrase ne décrit pas correctement l'image, l'étiquette sera 0.

task_mask_lm (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter le masked language modeling (tel qu'utilisé dans les modèles de pré-entraînement comme BERT) à l'objectif de perte.

task_obj_predict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter la prédiction d'objets, la prédiction d'attributs et la régression de caractéristiques à l'objectif de perte.

task_qa (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter la perte de question-réponse à l'objectif

visual_obj_loss (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non calculer l'objectif de perte de prédiction d'objets

visual_attr_loss (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ou non calculer l'objectif de perte de prédiction d'attributs

visual_feat_loss (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ou non calculer l'objectif de perte de régression des caractéristiques

pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

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.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un LxmertModel. Elle est utilisée pour instancier un modèle Lxmert 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 [unc-nlp/lxmert-base-uncased](https://huggingface.co/unc-nlp/lxmert-base-uncased)

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.

## LxmertTokenizer[[transformers.BertTokenizer]]

#### transformers.BertTokenizer[[transformers.BertTokenizer]]

```python
transformers.BertTokenizer(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bert/tokenization_bert.py#L41)

**Paramètres :**

vocab (`str` ou `dict[str, int]`, *facultatif*) : Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis `vocab_file`.

do_lower_case (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut mettre l'entrée en minuscules lors de la tokenisation.

unk_token (`str`, *facultatif*, valeur par défaut `"[UNK]"`) : le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.

sep_token (`str`, *facultatif*, valeur par défaut `"[SEP]"`) : le jeton séparateur, utilisé lors de la construction d'une séquence à partir de plusieurs séquences, par exemple deux séquences pour la classification de séquences ou un texte et une question pour le question answering. Il est également utilisé comme dernier jeton d'une séquence construite avec des jetons spéciaux.

pad_token (`str`, *facultatif*, par défaut `"[PAD]"`) : le jeton utilisé pour le bourrage, par exemple lors du groupement de séquences de longueurs différentes.

cls_token (`str`, *facultatif*, par défaut `"[CLS]"`) : le jeton de classifieur utilisé lors de la classification de séquence (classification de la séquence entière plutôt que la classification par jeton). C'est le premier jeton de la séquence lorsqu'elle est construite avec des jetons spéciaux.

mask_token (`str`, *facultatif*, valeur par défaut `"[MASK]"`) : Le jeton utilisé pour masquer les valeurs. C'est le jeton utilisé lors de l'entraînement de ce modèle avec le masquage de langage. C'est le jeton que le modèle cherchera à prédire.

tokenize_chinese_chars (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non tokeniser les caractères chinois.

strip_accents (`bool`, *facultatif*) : Indique s'il faut supprimer toutes les accents. Si cette option n'est pas spécifiée, sa valeur est déterminée par celle de `lowercase` (comme dans BERT d'origine).

Construit un tokenizer BERT (basé sur la bibliothèque tokenizers de HuggingFace). Fondé sur WordPiece.

Ce tokenizer hérite de [TokenizersBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette classe mère pour plus d’informations sur ces méthodes.

## Sorties spécifiques à Lxmert[[transformers.models.lxmert.modeling_lxmert.LxmertModelOutput]]

#### transformers.models.lxmert.modeling_lxmert.LxmertModelOutput[[transformers.models.lxmert.modeling_lxmert.LxmertModelOutput]]

```python
transformers.models.lxmert.modeling_lxmert.LxmertModelOutput(language_output: typing.Optional[torch.Tensor] = None, vision_output: typing.Optional[torch.Tensor] = None, pooled_output: typing.Optional[torch.Tensor] = None, language_hidden_states: tuple[torch.Tensor] | None = None, vision_hidden_states: tuple[torch.Tensor] | None = None, language_attentions: tuple[torch.Tensor] | None = None, vision_attentions: tuple[torch.Tensor] | None = None, cross_encoder_attentions: tuple[torch.Tensor] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L49)

**Paramètres :**

language_output (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) : Séquence d'états cachés à la sortie de la dernière couche de l'encodeur de langage.

vision_output (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) : Séquence d'états cachés à la sortie de la dernière couche de l'encodeur visuel.

pooled_output (`torch.Tensor` de forme `(batch_size, hidden_size)`) : État caché de la dernière couche du premier jeton de la séquence (jeton de classification, CLS) traité ensuite par une couche linéaire et une fonction d'activation Tanh. La couche

language_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche de cross-modalité) de forme `(batch_size, sequence_length, hidden_size)`.

vision_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche de cross-modalité) de forme `(batch_size, sequence_length, hidden_size)`.

language_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

vision_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

cross_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Les sorties de Lxmert, qui contiennent les derniers états cachés, les sorties agrégées et les probabilités d'attention pour les encodeurs du langage, visuel et de la multimodalité croisée. (note : l'encodeur visuel de Lxmert est appelé l'encodeur « relation-ship »)

#### transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput[[transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput]]

```python
transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, prediction_logits: typing.Optional[torch.Tensor] = None, cross_relationship_score: typing.Optional[torch.Tensor] = None, question_answering_score: typing.Optional[torch.Tensor] = None, language_hidden_states: tuple[torch.Tensor] | None = None, vision_hidden_states: tuple[torch.Tensor] | None = None, language_attentions: tuple[torch.Tensor] | None = None, vision_attentions: tuple[torch.Tensor] | None = None, cross_encoder_attentions: tuple[torch.Tensor] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L136)

**Paramètres :**

loss (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) : Perte totale, définie comme la somme de la perte de modélisation du langage masqué et de la perte de prédiction de la séquence suivante (classification).

prediction_logits (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) : Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).

cross_relationship_score (`torch.Tensor` de forme `(batch_size, 2)`) : Scores de prédiction de l'objectif de correspondance textuelle (tête de classification) (scores de continuation Vrai/Faux avant SoftMax).

question_answering_score (`torch.Tensor` de forme `(batch_size, n_qa_answers)`) : Scores de prédiction de l'objectif de question answering (classification).

language_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche de cross-modalité) de forme `(batch_size, sequence_length, hidden_size)`.

vision_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche de cross-modalité) de forme `(batch_size, sequence_length, hidden_size)`.

language_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

vision_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

cross_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Type de sortie de [LxmertForPreTraining](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertForPreTraining).

#### transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput[[transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput]]

```python
transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, question_answering_score: typing.Optional[torch.Tensor] = None, language_hidden_states: tuple[torch.Tensor] | None = None, vision_hidden_states: tuple[torch.Tensor] | None = None, language_attentions: tuple[torch.Tensor] | None = None, vision_attentions: tuple[torch.Tensor] | None = None, cross_encoder_attentions: tuple[torch.Tensor] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L94)

**Paramètres :**

loss (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) : Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss.k.

question_answering_score (`torch.Tensor` de forme `(batch_size, n_qa_answers)`, *facultatif*) : Scores de prédiction de l'objectif de question answering (classification).

language_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche de cross-modalité) de forme `(batch_size, sequence_length, hidden_size)`.

vision_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche de cross-modalité) de forme `(batch_size, sequence_length, hidden_size)`.

language_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

vision_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

cross_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Type de sortie de [LxmertForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertForQuestionAnswering).

## LxmertModel[[transformers.LxmertModel]]

#### transformers.LxmertModel[[transformers.LxmertModel]]

```python
transformers.LxmertModel(config: LxmertConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L675)

**Paramètres :**

config ([LxmertConfig](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertConfig)) : 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.

Le modèle Lxmert brut, qui produit des états cachés bruts sans aucune tête spécifique 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.LxmertModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, visual_feats: typing.Optional[torch.Tensor] = None, visual_pos: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, visual_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L690)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

visual_feats (`torch.Tensor` de forme `(batch_size, num_visual_features, visual_feat_dim)`) : Cette entrée représente des caractéristiques visuelles. Il s'agit de caractéristiques d'objets obtenues par pooling ROI à partir de boîtes englobantes, en utilisant un modèle faster-RCNN) Elles ne sont actuellement pas fournies par la bibliothèque transformers.

visual_pos (`torch.Tensor` de forme `(batch_size, num_visual_features, visual_pos_dim)`) : Cette entrée représente des caractéristiques spatiales correspondant à leurs caractéristiques visuelles relatives (via l’index). Le modèle LXMERT pré-entraîné s’attend à ce que ces caractéristiques spatiales soient des boîtes englobantes normalisées sur une échelle de 0 à 1. Elles ne sont actuellement pas fournies par la bibliothèque transformers.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

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.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

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

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

**Retourne :** [LxmertModelOutput](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertModelOutput) ou `tuple(torch.Tensor)`

Un [LxmertModelOutput](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments en fonction de la configuration ([LxmertConfig](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertConfig)) et des entrées.

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

- **language_output** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur de langage.
- **vision_output** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur visuel.
- **pooled_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification, CLS) traité ensuite par une couche linéaire et une fonction d'activation Tanh. La couche
- **language_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche inter-modalité) de forme `(batch_size, sequence_length, hidden_size)`.
- **vision_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche inter-modale) de forme `(batch_size, sequence_length, hidden_size)`.
- **language_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **vision_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

## LxmertForPreTraining[[transformers.LxmertForPreTraining]]

#### transformers.LxmertForPreTraining[[transformers.LxmertForPreTraining]]

```python
transformers.LxmertForPreTraining(config: LxmertConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L826)

**Paramètres :**

config ([LxmertConfig](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertConfig)) : 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.

Le modèle Lxmert avec une tête de pré-entraînement spécifiée 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.LxmertForPreTraining.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, visual_feats: typing.Optional[torch.Tensor] = None, visual_pos: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, visual_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, obj_labels: dict[str, tuple[torch.Tensor, torch.Tensor]] | None = None, matched_label: typing.Optional[torch.LongTensor] = None, ans: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L976)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

visual_feats (`torch.Tensor` de forme `(batch_size, num_visual_features, visual_feat_dim)`) : Cette entrée représente des caractéristiques visuelles. Il s'agit de caractéristiques d'objets obtenues par pooling ROI à partir de boîtes englobantes, en utilisant un modèle faster-RCNN) Elles ne sont actuellement pas fournies par la bibliothèque transformers.

visual_pos (`torch.Tensor` de forme `(batch_size, num_visual_features, visual_pos_dim)`) : Cette entrée représente des caractéristiques spatiales correspondant à leurs caractéristiques visuelles relatives (via l’index). Le modèle LXMERT pré-entraîné s’attend à ce que ces caractéristiques spatiales soient des boîtes englobantes normalisées sur une échelle de 0 à 1. Elles ne sont actuellement pas fournies par la bibliothèque transformers.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

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 (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans `[-100, 0, ..., config.vocab_size]` (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est dans `[0, ..., config.vocab_size]`.

obj_labels (`dict[Str : tuple[torch.Tensor, torch.Tensor]]`, *facultatif*) : chaque clé porte le nom de l'une des pertes visuelles et chaque élément du tuple a la forme `(batch_size, num_features)` et `(batch_size, num_features, visual_feature_dim)` pour l'identifiant de l'étiquette et le score de l'étiquette respectivement

matched_label (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour calculer la perte de classification indiquant si l'entrée texte correspond à l'image. L'entrée doit être une paire de séquences (voir la docstring de `input_ids`). Les indices doivent être dans `[0, 1]` : - 0 indique que la phrase ne correspond pas à l'image, - 1 indique que la phrase correspond à l'image.

ans (`Torch.Tensor` de forme `(batch_size)`, *facultatif*) : une représentation one hot de la bonne réponse *facultatif*

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

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

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

**Retourne :** [LxmertForPreTrainingOutput](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput) ou `tuple(torch.Tensor)`

Un [LxmertForPreTrainingOutput](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput) 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 ([LxmertConfig](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertConfig)) et les entrées.

La méthode forward de [LxmertForPreTraining](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertForPreTraining) 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** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Perte totale, définie comme la somme de la perte de modélisation de langage masquée et de la perte de prédiction de la séquence suivante (classification).
- **prediction_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **cross_relationship_score** (`torch.Tensor` de forme `(batch_size, 2)`) -- Scores de prédiction de l'objectif d'appariement textuel (tête de classification) (scores de continuation Vrai/Faux avant SoftMax).
- **question_answering_score** (`torch.Tensor` de forme `(batch_size, n_qa_answers)`) -- Scores de prédiction de l'objectif de question answering (classification).
- **language_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche inter-modalité) de forme `(batch_size, sequence_length, hidden_size)`.
- **vision_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche inter-modale) de forme `(batch_size, sequence_length, hidden_size)`.
- **language_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **vision_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
```

## LxmertForQuestionAnswering[[transformers.LxmertForQuestionAnswering]]

#### transformers.LxmertForQuestionAnswering[[transformers.LxmertForQuestionAnswering]]

```python
transformers.LxmertForQuestionAnswering(config: LxmertConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L1123)

**Paramètres :**

config ([LxmertConfig](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertConfig)) : 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 Lxmert avec une tête de réponse visuelle en haut pour les tâches de QA en aval

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.LxmertForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, visual_feats: typing.Optional[torch.Tensor] = None, visual_pos: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, visual_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/lxmert/modeling_lxmert.py#L1215)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

visual_feats (`torch.Tensor` de forme `(batch_size, num_visual_features, visual_feat_dim)`) : Cette entrée représente des caractéristiques visuelles. Il s'agit de caractéristiques d'objets obtenues par pooling ROI à partir de boîtes englobantes, en utilisant un modèle faster-RCNN) Elles ne sont actuellement pas fournies par la bibliothèque transformers.

visual_pos (`torch.Tensor` de forme `(batch_size, num_visual_features, visual_pos_dim)`) : Cette entrée représente des caractéristiques spatiales correspondant à leurs caractéristiques visuelles relatives (via l’index). Le modèle LXMERT pré-entraîné s’attend à ce que ces caractéristiques spatiales soient des boîtes englobantes normalisées sur une échelle de 0 à 1. Elles ne sont actuellement pas fournies par la bibliothèque transformers.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

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 (`Torch.Tensor` de forme `(batch_size)`, *facultatif*) : Représentation one-hot de la bonne réponse

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

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

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

**Retourne :** [LxmertForQuestionAnsweringOutput](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput) ou `tuple(torch.Tensor)`

Un [LxmertForQuestionAnsweringOutput](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput) 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 ([LxmertConfig](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertConfig)) et les entrées.

La méthode forward de [LxmertForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.LxmertForQuestionAnswering) 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** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Perte totale, définie comme la somme de la perte de modélisation de langage masquée et de la perte de prédiction de la séquence suivante (classification).k.
- **question_answering_score** (`torch.Tensor` de forme `(batch_size, n_qa_answers)`, *facultatif*) -- Scores de prédiction de l'objectif de question answering (classification).
- **language_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche inter-modalité) de forme `(batch_size, sequence_length, hidden_size)`.
- **vision_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 les fonctionnalités d'entrée + un pour la sortie de chaque couche inter-modale) de forme `(batch_size, sequence_length, hidden_size)`.
- **language_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **vision_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> from transformers import AutoTokenizer, LxmertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("unc-nlp/lxmert-base-uncased")
>>> model = LxmertForQuestionAnswering.from_pretrained("unc-nlp/lxmert-base-uncased")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```

