Transformers documentation
LXMERT
Ce modèle a été publié dans HF papers le 2019-08-20 et ajouté à Hugging Face Transformers le 2020-11-16.
LXMERT
Aperçu
Le modèle LXMERT a été proposé dans LXMERT: Learning Cross-Modality Encoder Representations from Transformers 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 de modélisation de langage masquée, 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 d’objectifs 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é de 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 masquage de modélisation du langage, 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 aux questions sur les 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 aux 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 ; et nous présentons également plusieurs visualisations d’attention pour les différents encodeurs
Ce modèle a été contribué par eltoto1219. Le code d'origine peut être trouvé ici.
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 visuelles spatiales convient.
- Les états cachés du langage et les états cachés visuels que LXMERT produit sont tous deux passés par la couche de cross-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 de l'encodeur bidirectionnel inter-modalités 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 inter-modalités 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
LxmertConfig
classe transformers.LxmertConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522hidden_size: int = 768num_attention_heads: int = 12num_qa_labels: int = 9500num_object_labels: int = 1600num_attr_labels: int = 400intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2initializer_range: float = 0.02l_layers: int = 9x_layers: int = 5r_layers: int = 5visual_feat_dim: int = 2048visual_pos_dim: int = 4visual_loss_normalizer: float = 6.67task_matched: bool = Truetask_mask_lm: bool = Truetask_obj_predict: bool = Truetask_qa: bool = Truevisual_obj_loss: bool = Truevisual_attr_loss: bool = Truevisual_feat_loss: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonetie_word_embeddings: bool = True )
Paramètres
- vocab_size (
int, facultatif, par défaut30522) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - num_attention_heads (
int, facultatif, valeur par défaut12) — 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) — Ce paramètre 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 tâches de 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 que lxmert sera en mesure de classifier à partir d’une fonction d’objet agrégée. - num_attr_labels (
int, facultatif, valeur par défaut 400) — Ce paramètre 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ée. - intermediate_size (
int, facultatif, par défaut3072) — Dimension des représentations du MLP. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - hidden_dropout_prob (
Union[float, int], facultatif, par défaut0.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, par défaut0.1) — Le taux de dropout appliqué aux probabilités d'attention. - max_position_embeddings (
int, facultatif, par défaut512) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - type_vocab_size (
int, facultatif, par défaut2) — La taille du vocabulaire destoken_type_ids. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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 agrégées utilisées comme entrée pour le modèle, représentant 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, le plus souvent, cela représente 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 facteur représente le coefficient de mise à l'échelle par lequel chaque perte visuelle est multipliée si, lors de la préformation, on décide d'entraîner le modèle avec plusieurs objectifs de perte basés sur la vision. - task_matched (
bool, facultatif, par défautTrue) — 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éfautTrue) — 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, par défautTrue) — 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, par défautTrue) — Indique s'il faut ajouter la perte de question-réponse à l'objectif - visual_obj_loss (
bool, facultatif, par défautTrue) — Indique s'il faut ou non calculer l'objectif de perte de prédiction d'objets - visual_attr_loss (
bool, facultatif, valeur par défautTrue) — Indique s'il faut ou non calculer l'objectif de perte de prédiction d'attributs - visual_feat_loss (
bool, facultatif, par défautTrue) — Indique s'il faut ou non calculer l'objectif de perte de régression des caractéristiques - pad_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle.
Ceci est 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, définissant ainsi 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
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
LxmertTokenizer
classe transformers.BertTokenizer
< source >( vocab: str | dict[str, int] | None = Nonedo_lower_case: bool = Trueunk_token: str = '[UNK]'sep_token: str = '[SEP]'pad_token: str = '[PAD]'cls_token: str = '[CLS]'mask_token: str = '[MASK]'tokenize_chinese_chars: bool = Truestrip_accents: bool | None = None**kwargs )
Paramètres
- vocab (
stroudict[str, int], facultatif) — Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuisvocab_file. - do_lower_case (
bool, facultatif, par défautTrue) — Indique s'il faut mettre l'entrée en minuscules lors de la tokenisation. - unk_token (
str, facultatif, 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, 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 regroupement 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, 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 modélisation de langage masquée. C'est le jeton que le modèle cherchera à prédire. - tokenize_chinese_chars (
bool, facultatif, par défautTrue) — 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, elle est déterminée par la valeur delowercase(comme dans BERT d'origine).
Construire un tokenizer BERT (basé sur la bibliothèque tokenizers de HuggingFace). Basé sur WordPiece.
Ce tokenizer hérite de TokenizersBackend, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.
Sorties spécifiques à Lxmert
classe transformers.models.lxmert.modeling_lxmert.LxmertModelOutput
< source >( language_output: typing.Optional[torch.Tensor] = Nonevision_output: typing.Optional[torch.Tensor] = Nonepooled_output: typing.Optional[torch.Tensor] = Nonelanguage_hidden_states: tuple[torch.Tensor] | None = Nonevision_hidden_states: tuple[torch.Tensor] | None = Nonelanguage_attentions: tuple[torch.Tensor] | None = Nonevision_attentions: tuple[torch.Tensor] | None = Nonecross_encoder_attentions: tuple[torch.Tensor] | None = None )
Paramètres
- language_output (
torch.Tensorde 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.Tensorde 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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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. (remarque : l’encodeur visuel dans Lxmert est appelé l’encodeur « relation-ship »)
classe transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput
< source >( loss: typing.Optional[torch.Tensor] = Noneprediction_logits: typing.Optional[torch.Tensor] = Nonecross_relationship_score: typing.Optional[torch.Tensor] = Nonequestion_answering_score: typing.Optional[torch.Tensor] = Nonelanguage_hidden_states: tuple[torch.Tensor] | None = Nonevision_hidden_states: tuple[torch.Tensor] | None = Nonelanguage_attentions: tuple[torch.Tensor] | None = Nonevision_attentions: tuple[torch.Tensor] | None = Nonecross_encoder_attentions: tuple[torch.Tensor] | None = None )
Paramètres
- loss (
*optional*, returned whenlabelsis provided,torch.Tensorof shape(1,)) — Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss. - prediction_logits (
torch.Tensorde 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.Tensorde forme(batch_size, 2)) — Scores de prédiction de l'objectif d'appariement textuel (tête de classification) (scores de continuation True/False avant SoftMax). - question_answering_score (
torch.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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.
classe transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonequestion_answering_score: typing.Optional[torch.Tensor] = Nonelanguage_hidden_states: tuple[torch.Tensor] | None = Nonevision_hidden_states: tuple[torch.Tensor] | None = Nonelanguage_attentions: tuple[torch.Tensor] | None = Nonevision_attentions: tuple[torch.Tensor] | None = Nonecross_encoder_attentions: tuple[torch.Tensor] | None = None )
Paramètres
- loss (
*optional*, returned whenlabelsis provided,torch.Tensorof 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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuplet detorch.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.
LxmertModel
classe transformers.LxmertModel
< source >( config: LxmertConfig )
Paramètres
- config (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() 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonevisual_feats: typing.Optional[torch.Tensor] = Nonevisual_pos: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonevisual_attention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LxmertModelOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- visual_feats (
torch.Tensorde forme(batch_size, num_visual_features, visual_feat_dim)) — Cette entrée représente des caractéristiques visuelles. Elles sont des caractéristiques d'objets obtenues par pooling ROI à partir de boîtes englobantes à l'aide d'un modèle faster-RCNN)Ces éléments ne sont actuellement pas fournis par la bibliothèque transformers.
- visual_pos (
torch.Tensorde 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 àCes éléments ne sont actuellement pas fournis par la bibliothèque transformers.
- attention_mask (
torch.Tensorde 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 masqués.
- visual_attention_mask (
torch.Tensorde 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 masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que 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. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
LxmertModelOutput ou tuple(torch.Tensor)
Un LxmertModelOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LxmertConfig) et des entrées.
La méthode forward du modèle 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
Moduleplutô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.Tensorde 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.Tensorde 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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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
classe transformers.LxmertForPreTraining
< source >( config: LxmertConfig )
Paramètres
- config (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() 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonevisual_feats: typing.Optional[torch.Tensor] = Nonevisual_pos: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonevisual_attention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneobj_labels: dict[str, tuple[torch.Tensor, torch.Tensor]] | None = Nonematched_label: typing.Optional[torch.LongTensor] = Noneans: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LxmertForPreTrainingOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- visual_feats (
torch.Tensorde forme(batch_size, num_visual_features, visual_feat_dim)) — Cette entrée représente des caractéristiques visuelles. Elles sont des caractéristiques d'objets obtenues par pooling ROI à partir de boîtes englobantes à l'aide d'un modèle faster-RCNN)Ces éléments ne sont actuellement pas fournis par la bibliothèque transformers.
- visual_pos (
torch.Tensorde 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 àCes éléments ne sont actuellement pas fournis par la bibliothèque transformers.
- attention_mask (
torch.Tensorde 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 masqués.
- visual_attention_mask (
torch.Tensorde 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 masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde 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 deinput_ids). Les jetons dont l'indice est défini sur-100sont 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.LongTensorde 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 (voirinput_idsdocstring) 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.Tensorde 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. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
LxmertForPreTrainingOutput ou tuple(torch.Tensor)
Un LxmertForPreTrainingOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LxmertConfig) et des entrées.
La méthode forward de 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
Moduleplutô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 whenlabelsis provided,torch.Tensorof 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.Tensorde 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.Tensorde 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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
LxmertForQuestionAnswering
classe transformers.LxmertForQuestionAnswering
< source >( config: LxmertConfig )
Paramètres
- config (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() 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonevisual_feats: typing.Optional[torch.Tensor] = Nonevisual_pos: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonevisual_attention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LxmertForQuestionAnsweringOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- visual_feats (
torch.Tensorde forme(batch_size, num_visual_features, visual_feat_dim)) — Cette entrée représente des caractéristiques visuelles. Elles sont des caractéristiques d'objets obtenues par pooling ROI à partir de boîtes englobantes à l'aide d'un modèle faster-RCNN)Ces éléments ne sont actuellement pas fournis par la bibliothèque transformers.
- visual_pos (
torch.Tensorde 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 àCes éléments ne sont actuellement pas fournis par la bibliothèque transformers.
- attention_mask (
torch.Tensorde 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 masqués.
- visual_attention_mask (
torch.Tensorde 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 masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
Torch.Tensorde 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. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
LxmertForQuestionAnsweringOutput ou tuple(torch.Tensor)
Un LxmertForQuestionAnsweringOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LxmertConfig) et des entrées.
La méthode forward de 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
Moduleplutô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 whenlabelsis provided,torch.Tensorof 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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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 :
>>> 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)
...