Transformers documentation
XLNet
Ce modèle a été publié dans HF papers le 2019-06-19 et ajouté à Hugging Face Transformers le 2020-11-16.
XLNet
Aperçu
Le modèle XLNet a été proposé dans XLNet: Generalized Autoregressive Pretraining for Language Understanding par Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le. XLnet est une extension du modèle Transformer-XL, pré-entraînée à l’aide d’une méthode autorégressive afin d’apprendre des contextes bidirectionnels en maximisant la vraisemblance attendue sur toutes les permutations de l’ordre de factorisation de la séquence d’entrée.
L'abstract de l'article est le suivant :
Grâce à sa capacité à modéliser des contextes bidirectionnels, le pré-entraînement par auto-encodage avec débruitage, tel que BERT, obtient de meilleures performances que les approches de pré-entraînement basées sur la modélisation de langage autorégressive. Toutefois, en s’appuyant sur la corruption de l’entrée par des masques, BERT néglige la dépendance entre les positions masquées et souffre d’une divergence entre le pré-entraînement et l’ajustement fin. Compte tenu de ces avantages et inconvénients, nous proposons XLNet, une méthode de pré-entraînement autorégressive généralisée qui (1) permet d’apprendre des contextes bidirectionnels en maximisant la vraisemblance attendue sur toutes les permutations de l’ordre de factorisation et (2) surmonte les limites de BERT grâce à sa formulation autorégressive. De plus, XLNet intègre les idées de Transformer-XL, le modèle autorégressive de pointe, dans le pré-entraînement. Empiriquement, dans des conditions expérimentales comparables, XLNet surpasse BERT sur 20 tâches, souvent avec une large marge, notamment en réponse à des questions, inférence de langage naturel, analyse de sentiments et classement de documents.
Ce modèle a été contribué par thomwolf. Le code d'origine est disponible ici.
Conseils d'utilisation
- Le motif d'attention spécifique peut être contrôlé lors de l'entraînement et de l'évaluation à l'aide de l'entrée
perm_mask. - En raison de la difficulté d’entraîner un modèle entièrement auto-régressif sur divers ordres de factorisation, XLNet est pré-entraîné en utilisant uniquement un sous-ensemble des jetons de sortie comme cible, sélectionnés à l’aide de l’entrée
target_mapping. - Pour utiliser XLNet pour le décodage séquentiel (c'est-à-dire pas dans un contexte entièrement bidirectionnel), utilisez les entrées
perm_maskettarget_mappingpour contrôler la portée de l'attention et les sorties - XLNet est l’un des rares modèles qui n’a pas de limite de longueur de séquence.
- XLNet n'est pas un modèle autorégressif traditionnel, mais il s'appuie sur une stratégie d'entraînement qui en est dérivée. Il permuter les jetons de la phrase, puis permet au modèle d'utiliser les n derniers jetons pour prédire le jeton n+1. Comme tout cela est réalisé à l'aide d'un masque, la phrase est en réalité transmise au modèle dans le bon ordre, mais au lieu de masquer les n premiers jetons pour n+1, XLNet utilise un masque qui masque les jetons précédents selon une permutation donnée de 1,…,longueur de la séquence.
- XLNet utilise également le même mécanisme de récurrence que Transformer-XL pour construire des dépendances à long terme.
Ressources
- Guide de la tâche de classification de texte
- Guide de la tâche de classification de jetons
- Guide de la tâche de réponse aux questions
- Guide de la tâche de modélisation de langage causale
- Guide de la tâche de choix multiples
XLNetConfig
classe transformers.XLNetConfig
< 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 = 32000d_model: int = 1024n_layer: int = 24n_head: int = 16d_inner: int = 4096d_head: int | None = Noneff_activation: str = 'gelu'attn_type: str = 'bi'initializer_range: float = 0.02layer_norm_eps: float = 1e-12dropout: float | int = 0.1mem_len: int | None = 512reuse_len: int | None = Noneuse_mems_eval: bool = Trueuse_mems_train: bool = Falsebi_data: bool = Falseclamp_len: int = -1same_length: bool = Falsesummary_type: str = 'last'summary_use_proj: bool = Truesummary_activation: str = 'tanh'summary_last_dropout: float | int = 0.1start_n_top: int = 5end_n_top: int = 5pad_token_id: int | None = 5bos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = True )
Paramètres
- vocab_size (
int, facultatif, par défaut32000) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - d_model (
int, facultatif, par défaut1024) — Taille des couches encodeur et de la couche pooler. - n_layer (
int, facultatif, par défaut24) — Nombre de couches cachées dans le décodeur Transformer. - n_head (
int, facultatif, par défaut16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - d_inner (
int, facultatif, par défaut4096) — Dimension des représentations du MLP. - d_head (
int, facultatif) — La dimension des têtes d'attention. Si None, la valeur par défaut est hidden_size // num_attention_heads - ff_activation (
strouCallable, facultatif, valeur par défaut"gelu") — Fonction d'activation non linéaire (fonction ou chaîne de caractères). Si c'est une chaîne,"gelu","relu","silu"et"gelu_new"sont pris en charge. - attn_type (
str, facultatif, par défaut"bi") — Le type d'attention utilisé par le modèle. Définissez"bi"pour XLNet et"uni"pour Transformer-XL. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - layer_norm_eps (
float, facultatif, valeur par défaut1e-12) — L'épsilon utilisé par les couches de normalisation de couche. - dropout (
Union[float, int], facultatif, par défaut0.1) — Le taux appliqué à toutes les couches de dropout. - mem_len (
intouNone, facultatif) — Le nombre de jetons à mettre en cache. Les paires clé/valeur déjà précalculées lors d’un passage avant précédent ne seront pas recalculées. Consultez le tutoriel de démarrage rapide pour plus d’informations. - reuse_len (
int, facultatif) — Nombre de jetons du lot actuel à mettre en cache et à réutiliser à l’avenir. - use_mems_eval (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit utiliser le mécanisme de mémoire récurrente en mode d'évaluation. - use_mems_train (
bool, facultatif, valeur par défautFalse) — Indique si le modèle doit utiliser le mécanisme de mémoire récurrente en mode d'entraînement.Pour le pré-entraînement, il est recommandé de définir `use_mems_train` sur `True`. Pour l'ajustement fin, il est recommandé de définir `use_mems_train` sur `False`, comme discuté [ici](https://github.com/zihangdai/xlnet/issues/41#issuecomment-505102587). Si `use_mems_train` est défini sur `True`, il faut s'assurer que les lots d'entraînement sont correctement pré-traités, *par exemple* `batch_1 = [[This line is], [This is the]]` et `batch_2 = [[ the first line], [ second line]]`, et que tous les lots sont de taille égale. - bi_data (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser un pipeline d'entrée bidirectionnel. Généralement défini surTruelors du pré-entraînement et surFalselors de l'ajustement fin. - clamp_len (
int, facultatif, valeur par défaut -1) — Limite toutes les distances relatives supérieures à clamp_len. Définir cet attribut à -1 signifie qu'aucune limitation n'est appliquée. - same_length (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser la même longueur d'attention pour chaque jeton. - summary_type (
str, facultatif, valeur par défaut « last ») — Argument utilisé lors de la résumation de séquence. Utilisé dans les modèles de classification de séquence et de choix multiple. Doit être l'une des options suivantes :"last": prend l’état caché du dernier jeton (comme XLNet)."first": prend l’état caché du premier jeton (comme BERT)."mean": Prendre la moyenne des états cachés de tous les jetons."cls_index": Fournir un Tensor indiquant la position du jeton de classification (comme pour GPT/GPT-2)."attn": Non implémenté pour le moment, utilisez l'attention multi-têtes.
- summary_use_proj (
bool, facultatif, par défautTrue) — Argument utilisé lors de la résumation de séquence. Utilisé dans les modèles de classification de séquence et de choix multiples. Indique s'il faut ou non ajouter une projection après l'extraction du vecteur. - summary_activation (
str, facultatif) — Argument utilisé lors de la résumée de séquence. Utilisé dans les modèles de classification de séquence et de choix multiples. Passez"tanh"pour une activation tanh sur la sortie, toute autre valeur entraînera l'absence d'activation. - summary_last_dropout (
float, facultatif, valeur par défaut 0,1) — Utilisé dans les modèles de classification de séquences et de choix multiples. Le taux de dropout à utiliser après la projection et l'activation. - start_n_top (
int, facultatif, valeur par défaut 5) — Utilisé dans le script d'évaluation SQuAD. - end_n_top (
int, facultatif, valeur par défaut 5) — Utilisé dans le script d'évaluation SQuAD. - pad_token_id (
int, facultatif, valeur par défaut5) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut1) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut2) — 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 XLNetModel. Elle est utilisée pour instancier un modèle Xlnet 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 xlnet/xlnet-large-cased
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.
Exemples :
>>> from transformers import XLNetConfig, XLNetModel
>>> # Initializing a XLNet configuration
>>> configuration = XLNetConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = XLNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configXLNetTokenizer
classe transformers.XLNetTokenizer
< source >( vocab: str | list[tuple[str, float]] | None = Noneunk_id: int = 0do_lower_case = Falseremove_space = Truekeep_accents = Falsebos_token = '<s>'eos_token = '</s>'unk_token = '<unk>'sep_token = '<sep>'pad_token = '<pad>'cls_token = '<cls>'mask_token = '<mask>'_spm_precompiled_charsmap = Noneadditional_special_tokens = None**kwargs )
Paramètres
- vocab (
list of tuples, facultatif) — Liste de tuples (jeton, score) pour le modèle Unigram. Si non fourni, une liste vide est utilisée. - unk_id (
int, facultatif, valeur par défaut 0) — L'identifiant du jeton inconnu dans le vocabulaire. - do_lower_case (
bool, facultatif, valeur par défautFalse) — Indique s'il faut mettre l'entrée en minuscules lors de la tokenisation. - remove_space (
bool, facultatif, par défautTrue) — Indique s'il faut retirer les espaces superflus lors de la tokenisation (suppression des espaces en trop avant et après la chaîne). - keep_accents (
bool, facultatif, valeur par défautFalse) — Indique s'il faut conserver les accents lors de la tokenisation. - bos_token (
str, facultatif, défaut"<s>") — Le jeton de début de séquence utilisé lors de la préformation. Peut être utilisé comme jeton de classifieur de séquence.Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas ce jeton qui est utilisé pour le début de la séquence. Le jeton utilisé est
cls_token. - eos_token (
str, facultatif, défaut :"</s>") — Le jeton de fin de séquence. Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas le jeton utilisé pour la fin de séquence. Le jeton utilisé est sep_token.Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas ce jeton qui est utilisé pour la fin de séquence. Le jeton utilisé est le
sep_token. - 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 classification 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. - additional_special_tokens (
list[str], facultatif, par défaut["<eop>", "<eod>"]) — Jetons spéciaux supplémentaires utilisés par le tokeniseur.
Construit un tokeniseur XLNet (basé sur la bibliothèque tokenizers de HuggingFace). Basé sur Unigram.
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.
get_special_tokens_mask
< source >( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
Paramètres
- token_ids_0 — Liste des identifiants de la séquence (éventuellement déjà formatée).
- token_ids_1 — Non utilisé lorsque
already_has_special_tokens=True. Doit être None dans ce cas. - already_has_special_tokens — Indique si la séquence est déjà formatée avec des jetons spéciaux.
Retourne
Une liste d'entiers dans l'intervalle [0, 1]
1 pour un jeton spécial, 0 pour un jeton de séquence.
Récupérer les identifiants de séquences à partir d'une liste de jetons à laquelle aucun jeton spécial n'a été ajouté.
Pour les tokenizers rapides, les data collators appellent cette fonction avec already_has_special_tokens=True pour construire un masque sur une séquence déjà formatée. Dans ce cas, nous calculons le masque en vérifiant l’appartenance à all_special_ids.
Sorties spécifiques à XLNet
classe transformers.models.xlnet.modeling_xlnet.XLNetModelOutput
< source >( last_hidden_state: Tensormems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- last_hidden_state (
torch.Tensorde forme(batch_size, num_predict, hidden_size)) — Séquence d'états cachés de la dernière couche du modèle.num_predictcorrespond àtarget_mapping.shape[1]. Sitarget_mappingestNone, alorsnum_predictcorrespond àsequence_length. - mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
Type de sortie de XLNetModel.
classe transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- loss (
torch.Tensorde forme (1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant). - logits (
torch.Tensorde forme(batch_size, num_predict, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).num_predictcorrespond àtarget_mapping.shape[1]. Sitarget_mappingestNone, alorsnum_predictcorrespond àsequence_length. - mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
Type de sortie de XLNetLMHeadModel.
classe transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelest fourni) — Perte de classification (ou de régression si config.num_labels==1). - logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax). - mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
Type de sortie de XLNetForSequenceClassification.
classe transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- loss (
torch.Tensorde forme (1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification. - logits (
torch.Tensorde forme(batch_size, num_choices)) — est la deuxième dimension des tenseurs d'entrée. (voir ci-dessus). Scores de classification (avant SoftMax).Scores de classification (avant SoftMax).
- mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
Type de sortie de XLNetForMultipleChoice.
classe transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification. - logits (
torch.Tensorde forme(batch_size, sequence_length, config.num_labels)) — Scores de classification (avant SoftMax). - mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
Type de sortie de XLNetForTokenClassificationOutput.
classe transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonestart_logits: typing.Optional[torch.Tensor] = Noneend_logits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — La perte totale d'extraction de segments est la somme d'une entropie croisée pour les positions de début et de fin. - start_logits (
torch.Tensorde forme(batch_size, sequence_length,)) — Scores de début d'intervalle (avant SoftMax). - end_logits (
torch.Tensorde forme(batch_size, sequence_length,)) — Scores de fin de segment (avant SoftMax). - mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
Type de sortie de XLNetForQuestionAnsweringSimple.
classe transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonestart_top_log_probs: typing.Optional[torch.Tensor] = Nonestart_top_index: typing.Optional[torch.LongTensor] = Noneend_top_log_probs: typing.Optional[torch.Tensor] = Noneend_top_index: typing.Optional[torch.LongTensor] = Nonecls_logits: typing.Optional[torch.Tensor] = Nonemems: list[torch.Tensor] | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé sistart_positionsetend_positionssont tous deux fournis) — Perte de classification, définie comme la somme des pertes de classification du jeton de début, du jeton de fin (et de is_impossible si fourni). - start_top_log_probs (
torch.Tensorde forme(batch_size, config.start_n_top), facultatif, renvoyé sistart_positionsouend_positionsn’est pas fourni) — Probabilités logarithmiques des config.start_n_top premières possibilités de jetons de départ (recherche par faisceau). - start_top_index (
torch.LongTensorde forme(batch_size, config.start_n_top), facultatif, renvoyé sistart_positionsouend_positionsn’est pas fourni) — Indices des config.start_n_top meilleures possibilités de jeton de départ (recherche par faisceau). - end_top_log_probs (
torch.Tensorde forme(batch_size, config.start_n_top * config.end_n_top), facultatif, renvoyé sistart_positionsouend_positionsn’est pas fourni) — Probabilités log desconfig.start_n_top * config.end_n_topmeilleures possibilités de jetons de fin (beam-search). - end_top_index (
torch.LongTensorde forme(batch_size, config.start_n_top * config.end_n_top), facultatif, renvoyé sistart_positionsouend_positionsn’est pas fourni) — Indices desconfig.start_n_top * config.end_n_topmeilleures possibilités de jetons de fin (beam-search). - cls_logits (
torch.Tensorde forme(batch_size,), facultatif, renvoyé sistart_positionsouend_positionsn'est pas fourni) — Probabilités log pour l'étiquetteis_impossibledes réponses. - mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
Type de sortie de XLNetForQuestionAnswering.
XLNetModel
classe transformers.XLNetModel
< source >( config: XLNetConfig )
Paramètres
- config (XLNetConfig) — 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 Xlnet 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.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetModelOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.Tensorde 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.
- 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.
- mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés (voirmemsci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_idscar ils ont déjà été calculés.use_memsdoit être défini surTruepour utilisermems. - perm_mask (
torch.Tensorde forme(batch_size, sequence_length, sequence_length), facultatif) — Masque indiquant le motif d'attention pour chaque jeton d'entrée, avec des valeurs choisies dans[0, 1]:- si
perm_mask[k, i, j] = 0, i prête attention à j dans le lot k ; - si
perm_mask[k, i, j] = 1, i ne porte pas attention à j dans le lot k.
Si non défini, chaque jeton porte attention sur tous les autres (attention bidirectionnelle complète). Utilisé uniquement lors de la préformation (pour définir l'ordre de factorisation) ou pour le décodage séquentiel (génération).
- si
- target_mapping (
torch.Tensorde forme(batch_size, num_predict, sequence_length), facultatif) — Masque indiquant les jetons de sortie à utiliser. Sitarget_mapping[k, i, j] = 1, la i-ème prédiction du lot k porte sur le j-ième jeton. Utilisé uniquement lors de la préformation pour la prédiction partielle ou le décodage séquentiel (génération). - token_type_ids (
torch.Tensorde 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.
- input_mask (
torch.Tensorde formebatch_size, sequence_length, facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Négatif deattention_mask, c'est-à-dire avec 0 pour les jetons réels et 1 pour le bourrage, conservé pour la compatibilité avec la base de code d'origine.Valeurs de masque sélectionnées dans
[0, 1]:- 1 pour les jetons qui sont masqués,
- 0 pour les jetons qui ne sont pas masqués.
Vous ne pouvez utiliser qu’un seul de
input_masketattention_mask. - 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. - use_mems (
bool, facultatif) — Indique s'il faut utiliser les états mémoire pour accélérer le décodage séquentiel. Si défini surTrue, le modèle utilise les états cachés des passes en avant précédentes pour calculer l'attention, ce qui peut améliorer considérablement les performances pour les tâches de décodage séquentiel. - 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
XLNetModelOutput ou tuple(torch.Tensor)
Un XLNetModelOutput 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 (XLNetConfig) et des entrées.
La méthode forward de XLNetModel 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.
last_hidden_state (
torch.Tensorde forme(batch_size, num_predict, hidden_size)) — Séquence d'états cachés de la dernière couche du modèle.num_predictcorrespond àtarget_mapping.shape[1]. Sitarget_mappingestNone, alorsnum_predictcorrespond àsequence_length.mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
XLNetLMHeadModel
classe transformers.XLNetLMHeadModel
< source >( config: XLNetConfig )
Paramètres
- config (XLNetConfig) — 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 XLNet avec une tête de modélisation de langage au sommet (couche linéaire dont les poids sont liés aux plongements d'entrée).
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.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → XLNetLMHeadModelOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.Tensorde 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.
- 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.
- mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés (voirmemsci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_idscar ils ont déjà été calculés.use_memsdoit être défini surTruepour utilisermems. - perm_mask (
torch.Tensorde forme(batch_size, sequence_length, sequence_length), facultatif) — Masque indiquant le motif d'attention pour chaque jeton d'entrée, avec des valeurs choisies dans[0, 1]:- si
perm_mask[k, i, j] = 0, i prête attention à j dans le lot k ; - si
perm_mask[k, i, j] = 1, i ne porte pas attention à j dans le lot k.
Si non défini, chaque jeton porte attention sur tous les autres (attention bidirectionnelle complète). Utilisé uniquement lors de la préformation (pour définir l'ordre de factorisation) ou pour le décodage séquentiel (génération).
- si
- target_mapping (
torch.Tensorde forme(batch_size, num_predict, sequence_length), facultatif) — Masque indiquant les jetons de sortie à utiliser. Sitarget_mapping[k, i, j] = 1, la i-ème prédiction du lot k porte sur le j-ième jeton. Utilisé uniquement lors de la préformation pour la prédiction partielle ou le décodage séquentiel (génération). - token_type_ids (
torch.Tensorde 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.
- input_mask (
torch.Tensorde formebatch_size, sequence_length, facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Négatif deattention_mask, c'est-à-dire avec 0 pour les jetons réels et 1 pour le bourrage, conservé pour la compatibilité avec la base de code d'origine.Valeurs de masque sélectionnées dans
[0, 1]:- 1 pour les jetons qui sont masqués,
- 0 pour les jetons qui ne sont pas masqués.
Vous ne pouvez utiliser qu’un seul de
input_masketattention_mask. - 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, num_predict), facultatif) — Étiquettes pour le modélisation de langage masquée.num_predictcorrespond àtarget_mapping.shape[1]. Sitarget_mappingestNone, alorsnum_predictcorrespond àsequence_length.Les étiquettes doivent correspondre aux mots masqués de l'entrée qui doivent être prédits et dépendent de
target_mapping. Notez que, pour effectuer un modèle de langage auto-régressif standard, un jetondoit être ajouté aux input_ids(voir la fonctionprepare_inputs_for_generationet les exemples ci-dessous)Les indices sont sélectionnés dans
[-100, 0, ..., config.vocab_size]Toutes les étiquettes définies sur-100sont ignorées, la perte n'est calculée que pour les étiquettes dans[0, ..., config.vocab_size] - use_mems (
bool, facultatif) — Indique s'il faut utiliser les états mémoire pour accélérer le décodage séquentiel. Si défini surTrue, le modèle utilise les états cachés des passes en avant précédentes pour calculer l'attention, ce qui peut améliorer considérablement les performances pour les tâches de décodage séquentiel. - 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. - logits_to_keep (
Union[int, torch.Tensor], facultatif, valeur par défaut0) — Si c'est unint, calcule les logits pour leslogits_to_keepderniers jetons. Si0, calcule les logits pour tous lesinput_ids(cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est untorch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).
Retourne
XLNetLMHeadModelOutput ou tuple(torch.Tensor)
Un XLNetLMHeadModelOutput 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 (XLNetConfig) et des entrées.
La méthode forward de XLNetLMHeadModel 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 (
torch.Tensorde forme (1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde forme(batch_size, num_predict, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).num_predictcorrespond àtarget_mapping.shape[1]. Sitarget_mappingestNone, alorsnum_predictcorrespond àsequence_length.mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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.
Exemples :
>>> from transformers import AutoTokenizer, XLNetLMHeadModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")
>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = torch.tensor(
... tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
... 0
... ) # We will predict the masked token
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
>>> target_mapping = torch.zeros(
... (1, 1, input_ids.shape[1]), dtype=torch.float
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping)
>>> next_token_logits = outputs[
... 0
... ] # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
>>> # The same way can the XLNetLMHeadModel be used to be trained by standard auto-regressive language modeling.
>>> input_ids = torch.tensor(
... tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
... 0
... ) # We will predict the masked token
>>> labels = torch.tensor(tokenizer.encode("cute", add_special_tokens=False)).unsqueeze(0)
>>> assert labels.shape[0] == 1, "only one word will be predicted"
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[
... :, :, -1
... ] = 1.0 # Previous tokens don't see last token as is done in standard auto-regressive lm training
>>> target_mapping = torch.zeros(
... (1, 1, input_ids.shape[1]), dtype=torch.float
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping, labels=labels)
>>> loss = outputs.loss
>>> next_token_logits = (
... outputs.logits
... ) # Logits have shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]XLNetForSequenceClassification
classe transformers.XLNetForSequenceClassification
< source >( config: XLNetConfig )
Paramètres
- config (XLNetConfig) — 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 XLNet avec une tête de classification/régression de séquence au sommet (une couche linéaire au-dessus de la sortie agrégée), par exemple pour les tâches GLUE.
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.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForSequenceClassificationOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.Tensorde 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.
- 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.
- mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés (voirmemsci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_idscar ils ont déjà été calculés.use_memsdoit être défini surTruepour utilisermems. - perm_mask (
torch.Tensorde forme(batch_size, sequence_length, sequence_length), facultatif) — Masque indiquant le motif d'attention pour chaque jeton d'entrée, avec des valeurs choisies dans[0, 1]:- si
perm_mask[k, i, j] = 0, i prête attention à j dans le lot k ; - si
perm_mask[k, i, j] = 1, i ne porte pas attention à j dans le lot k.
Si non défini, chaque jeton porte attention sur tous les autres (attention bidirectionnelle complète). Utilisé uniquement lors de la préformation (pour définir l'ordre de factorisation) ou pour le décodage séquentiel (génération).
- si
- target_mapping (
torch.Tensorde forme(batch_size, num_predict, sequence_length), facultatif) — Masque indiquant les jetons de sortie à utiliser. Sitarget_mapping[k, i, j] = 1, la i-ème prédiction du lot k porte sur le j-ième jeton. Utilisé uniquement lors de la préformation pour la prédiction partielle ou le décodage séquentiel (génération). - token_type_ids (
torch.Tensorde 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.
- input_mask (
torch.Tensorde formebatch_size, sequence_length, facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Négatif deattention_mask, c'est-à-dire avec 0 pour les jetons réels et 1 pour le bourrage, conservé pour la compatibilité avec la base de code d'origine.Valeurs de masque sélectionnées dans
[0, 1]:- 1 pour les jetons qui sont masqués,
- 0 pour les jetons qui ne sont pas masqués.
Vous ne pouvez utiliser qu’un seul de
input_masketattention_mask. - 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,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - use_mems (
bool, facultatif) — Indique s'il faut utiliser les états mémoire pour accélérer le décodage séquentiel. Si défini surTrue, le modèle utilise les états cachés des passes en avant précédentes pour calculer l'attention, ce qui peut améliorer considérablement les performances pour les tâches de décodage séquentiel. - 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
XLNetForSequenceClassificationOutput ou tuple(torch.Tensor)
Un XLNetForSequenceClassificationOutput 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 (XLNetConfig) et des entrées.
La méthode forward de XLNetForSequenceClassification 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 (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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 de classification mono-étiquette :
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Exemple de classification multi-étiquettes :
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLNetForSequenceClassification.from_pretrained(
... "xlnet/xlnet-large-cased", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossXLNetForMultipleChoice
classe transformers.XLNetForMultipleChoice
< source >( config: XLNetConfig )
Paramètres
- config (XLNetConfig) — 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 Xlnet avec une tête de classification à choix multiples au sommet (une couche linéaire au-dessus de la sortie agrégée et un softmax), par exemple pour les tâches RocStories/SWAG.
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.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForMultipleChoiceOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, num_choices, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- token_type_ids (
torch.LongTensorde forme(batch_size, num_choices, 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.
- input_mask (
torch.Tensorde formebatch_size, num_choices, sequence_length, facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Négatif deattention_mask, c'est-à-dire avec 0 pour les jetons réels et 1 pour le bourrage, conservé pour la compatibilité avec la base de code d'origine.Valeurs de masque sélectionnées dans
[0, 1]:- 1 pour les jetons qui sont masqués,
- 0 pour les jetons qui ne sont pas masqués.
Vous ne pouvez utiliser qu’un seul de
input_masketattention_mask. - 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.
- mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés (voirmemsci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_idscar ils ont déjà été calculés.use_memsdoit être défini surTruepour utilisermems. - perm_mask (
torch.Tensorde forme(batch_size, sequence_length, sequence_length), facultatif) — Masque indiquant le motif d'attention pour chaque jeton d'entrée, avec des valeurs choisies dans[0, 1]:- si
perm_mask[k, i, j] = 0, i prête attention à j dans le lot k ; - si
perm_mask[k, i, j] = 1, i ne porte pas attention à j dans le lot k.
Si non défini, chaque jeton porte attention sur tous les autres (attention bidirectionnelle complète). Utilisé uniquement lors de la préformation (pour définir l'ordre de factorisation) ou pour le décodage séquentiel (génération).
- si
- target_mapping (
torch.Tensorde forme(batch_size, num_predict, sequence_length), facultatif) — Masque indiquant les jetons de sortie à utiliser. Sitarget_mapping[k, i, j] = 1, la i-ème prédiction du lot k porte sur le j-ième jeton. Utilisé uniquement lors de la préformation pour la prédiction partielle ou le décodage séquentiel (génération). - inputs_embeds (
torch.Tensorde forme(batch_size, num_choices, 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 façon 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,), facultatif) — Étiquettes pour le calcul de la perte de classification à choix multiples. Les indices doivent être dans `[0, …, - use_mems (
bool, facultatif) — Indique s'il faut utiliser les états mémoire pour accélérer le décodage séquentiel. Si défini surTrue, le modèle utilise les états cachés des passes en avant précédentes pour calculer l'attention, ce qui peut améliorer considérablement les performances pour les tâches de décodage séquentiel. - 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
XLNetForMultipleChoiceOutput ou tuple(torch.Tensor)
Un XLNetForMultipleChoiceOutput 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 (XLNetConfig) et des entrées.
La méthode forward de XLNetForMultipleChoice 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 (
torch.Tensorde forme (1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde forme(batch_size, num_choices)) — num_choices est la deuxième dimension des tenseurs d’entrée. (voir input_ids ci-dessus).Scores de classification (avant SoftMax).
mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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, XLNetForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForMultipleChoice.from_pretrained("xlnet/xlnet-large-cased")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logitsXLNetForTokenClassification
classe transformers.XLNetForTokenClassification
< source >( config: XLNetConfig )
Paramètres
- config (XLNetConfig) — 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 transformateur Xlnet avec une tête de classification de jetons au sommet (une couche linéaire au-dessus de la sortie des états cachés), par exemple pour des tâches de reconnaissance d’entités nommées (NER).
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.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForTokenClassificationOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.Tensorde 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.
- 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.
- mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés (voirmemsci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_idscar ils ont déjà été calculés.use_memsdoit être défini surTruepour utilisermems. - perm_mask (
torch.Tensorde forme(batch_size, sequence_length, sequence_length), facultatif) — Masque indiquant le motif d'attention pour chaque jeton d'entrée, avec des valeurs choisies dans[0, 1]:- si
perm_mask[k, i, j] = 0, i prête attention à j dans le lot k ; - si
perm_mask[k, i, j] = 1, i ne porte pas attention à j dans le lot k.
Si non défini, chaque jeton porte attention sur tous les autres (attention bidirectionnelle complète). Utilisé uniquement lors de la préformation (pour définir l'ordre de factorisation) ou pour le décodage séquentiel (génération).
- si
- target_mapping (
torch.Tensorde forme(batch_size, num_predict, sequence_length), facultatif) — Masque indiquant les jetons de sortie à utiliser. Sitarget_mapping[k, i, j] = 1, la i-ème prédiction du lot k porte sur le j-ième jeton. Utilisé uniquement lors de la préformation pour la prédiction partielle ou le décodage séquentiel (génération). - token_type_ids (
torch.Tensorde 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.
- input_mask (
torch.Tensorde formebatch_size, sequence_length, facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Négatif deattention_mask, c'est-à-dire avec 0 pour les jetons réels et 1 pour le bourrage, conservé pour la compatibilité avec la base de code d'origine.Valeurs de masque sélectionnées dans
[0, 1]:- 1 pour les jetons qui sont masqués,
- 0 pour les jetons qui ne sont pas masqués.
Vous ne pouvez utiliser qu’un seul de
input_masketattention_mask. - 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,), facultatif) — Étiquettes pour le calcul de la perte de classification à choix multiples. Les indices doivent être dans[0, ..., num_choices]où num_choices est la taille de la deuxième dimension des tenseurs d’entrée. (voir input_ids ci-dessus) - use_mems (
bool, facultatif) — Indique s'il faut utiliser les états mémoire pour accélérer le décodage séquentiel. Si défini surTrue, le modèle utilisera les états cachés des passes en avant précédentes pour calculer l'attention, ce qui peut améliorer considérablement les performances pour les tâches de décodage séquentiel. États mémoire pour accélérer le décodage séquentiel. Si défini surTrue, le modèle utilisera les états cachés des passes en avant précédentes pour calculer l'attention, ce qui peut améliorer considérablement les performances pour les tâches de décodage séquentiel. - 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
XLNetForTokenClassificationOutput ou tuple(torch.Tensor)
Un XLNetForTokenClassificationOutput 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 (XLNetConfig) et des entrées.
La méthode forward de XLNetForTokenClassification 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 (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde forme(batch_size, sequence_length, config.num_labels)) — Scores de classification (avant SoftMax).mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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, XLNetForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForTokenClassification.from_pretrained("xlnet/xlnet-large-cased")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...XLNetForQuestionAnsweringSimple
classe transformers.XLNetForQuestionAnsweringSimple
< source >( config: XLNetConfig )
Paramètres
- config (XLNetConfig) — 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 XLNet avec une tête de classification de span au sommet pour les tâches de question-réponse extractives comme SQuAD (des couches linéaires au-dessus de la sortie des états cachés pour calculer les span start logits et les span end logits).
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.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForQuestionAnsweringSimpleOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.Tensorde 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.
- 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.
- mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés (voirmemsci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_idscar ils ont déjà été calculés.use_memsdoit être défini surTruepour utilisermems. - perm_mask (
torch.Tensorde forme(batch_size, sequence_length, sequence_length), facultatif) — Masque indiquant le motif d'attention pour chaque jeton d'entrée, avec des valeurs choisies dans[0, 1]:- si
perm_mask[k, i, j] = 0, i prête attention à j dans le lot k ; - si
perm_mask[k, i, j] = 1, i ne porte pas attention à j dans le lot k.
Si non défini, chaque jeton porte attention sur tous les autres (attention bidirectionnelle complète). Utilisé uniquement lors de la préformation (pour définir l'ordre de factorisation) ou pour le décodage séquentiel (génération).
- si
- target_mapping (
torch.Tensorde forme(batch_size, num_predict, sequence_length), facultatif) — Masque indiquant les jetons de sortie à utiliser. Sitarget_mapping[k, i, j] = 1, la i-ème prédiction du lot k porte sur le j-ième jeton. Utilisé uniquement lors de la préformation pour la prédiction partielle ou le décodage séquentiel (génération). - token_type_ids (
torch.Tensorde 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.
- input_mask (
torch.Tensorde formebatch_size, sequence_length, facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Négatif deattention_mask, c'est-à-dire avec 0 pour les jetons réels et 1 pour le bourrage, conservé pour la compatibilité avec la base de code d'origine.Valeurs de masque sélectionnées dans
[0, 1]:- 1 pour les jetons qui sont masqués,
- 0 pour les jetons qui ne sont pas masqués.
Vous ne pouvez utiliser qu’un seul de
input_masketattention_mask. - 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. - start_positions (
torch.Tensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) du début de l'interval étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont limitées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - end_positions (
torch.Tensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) de fin de l'intervalle étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont bornées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - use_mems (
bool, facultatif) — Indique s'il faut utiliser les états mémoire pour accélérer le décodage séquentiel. Si défini surTrue, le modèle utilise les états cachés des passes en avant précédentes pour calculer l'attention, ce qui peut améliorer considérablement les performances pour les tâches de décodage séquentiel. - 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
XLNetForQuestionAnsweringSimpleOutput ou tuple(torch.Tensor)
Un XLNetForQuestionAnsweringSimpleOutput 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 (XLNetConfig) et des entrées.
La méthode forward de XLNetForQuestionAnsweringSimple 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 (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — La perte totale d'extraction de span est la somme d'une entropie croisée pour les positions de début et de fin.start_logits (
torch.Tensorde forme(batch_size, sequence_length,)) — Scores de début de segment (avant SoftMax).end_logits (
torch.Tensorde forme(batch_size, sequence_length,)) — Scores de fin de segment (avant SoftMax).mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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, XLNetForQuestionAnsweringSimple
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-large-cased")
>>> 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)
...XLNetForQuestionAnswering
classe transformers.XLNetForQuestionAnswering
< source >( config: XLNetConfig )
Paramètres
- config (XLNetConfig) — 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 transformateur Xlnet avec une tête de classification de segments au sommet pour les tâches de question-réponse extractives comme
SQuAD (une couche linéaire au sommet de la sortie des états cachés pour calculer span start logits et span end logits).
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.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonemems: typing.Optional[torch.Tensor] = Noneperm_mask: typing.Optional[torch.Tensor] = Nonetarget_mapping: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinput_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneis_impossible: typing.Optional[torch.Tensor] = Nonecls_index: typing.Optional[torch.Tensor] = Nonep_mask: typing.Optional[torch.Tensor] = Noneuse_mems: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLNetForQuestionAnsweringOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.Tensorde 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.
- 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.
- mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés (voirmemsci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_idscar ils ont déjà été calculés.use_memsdoit être défini surTruepour utilisermems. - perm_mask (
torch.Tensorde forme(batch_size, sequence_length, sequence_length), facultatif) — Masque indiquant le motif d'attention pour chaque jeton d'entrée, avec des valeurs choisies dans[0, 1]:- si
perm_mask[k, i, j] = 0, i prête attention à j dans le lot k ; - si
perm_mask[k, i, j] = 1, i ne porte pas attention à j dans le lot k.
Si non défini, chaque jeton porte attention sur tous les autres (attention bidirectionnelle complète). Utilisé uniquement lors de la préformation (pour définir l'ordre de factorisation) ou pour le décodage séquentiel (génération).
- si
- target_mapping (
torch.Tensorde forme(batch_size, num_predict, sequence_length), facultatif) — Masque indiquant les jetons de sortie à utiliser. Sitarget_mapping[k, i, j] = 1, la i-ème prédiction du lot k porte sur le j-ième jeton. Utilisé uniquement lors de la préformation pour la prédiction partielle ou le décodage séquentiel (génération). - token_type_ids (
torch.Tensorde 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.
- input_mask (
torch.Tensorde formebatch_size, sequence_length, facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Négatif deattention_mask, c'est-à-dire avec 0 pour les jetons réels et 1 pour le bourrage, conservé pour la compatibilité avec la base de code d'origine.Valeurs de masque sélectionnées dans
[0, 1]:- 1 pour les jetons qui sont masqués,
- 0 pour les jetons qui ne sont pas masqués.
Vous ne pouvez utiliser qu’un seul de
input_masketattention_mask. - 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. - start_positions (
torch.Tensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) du début de l'interval étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont limitées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - end_positions (
torch.Tensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) de fin de l'intervalle étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont bornées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - is_impossible (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes indiquant si une question a une réponse ou non (SQuAD 2.0) - cls_index (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) du jeton de classification à utiliser comme entrée pour le calcul de la plausibilité de la réponse. - p_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque facultatif des jetons qui ne peuvent pas faire partie des réponses (par ex. [CLS], [PAD], …). 1.0 signifie que le jeton doit être masqué. 0.0 signifie que le jeton n’est pas masqué. - use_mems (
bool, facultatif) — Indique s'il faut utiliser les états mémoire pour accélérer le décodage séquentiel. Si défini surTrue, le modèle utilise les états cachés des passes en avant précédentes pour calculer l'attention, ce qui peut améliorer considérablement les performances pour les tâches de décodage séquentiel. - 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
XLNetForQuestionAnsweringOutput ou tuple(torch.Tensor)
Un XLNetForQuestionAnsweringOutput 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 (XLNetConfig) et des entrées.
La méthode forward de XLNetForQuestionAnswering 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 (
torch.Tensorde forme(1,), facultatif, renvoyé sistart_positionsetend_positionssont tous deux fournis) — Perte de classification, définie comme la somme des pertes de classification du jeton de début, du jeton de fin (et de is_impossible si fourni).start_top_log_probs (
torch.Tensorde forme(batch_size, config.start_n_top), facultatif, renvoyé sistart_positionsouend_positionsn'est pas fourni) — Probabilités logarithmiques des config.start_n_top premières possibilités de jetons de départ (recherche par faisceau).start_top_index (
torch.LongTensorde forme(batch_size, config.start_n_top), facultatif, renvoyé sistart_positionsouend_positionsn'est pas fourni) — Indices des config.start_n_top premières possibilités de jetons de départ (beam-search).end_top_log_probs (
torch.Tensorde forme(batch_size, config.start_n_top * config.end_n_top), facultatif, renvoyé sistart_positionsouend_positionsn’est pas fourni) — Probabilités logarithmiques desconfig.start_n_top * config.end_n_toppremières possibilités de jetons de fin (beam-search).end_top_index (
torch.LongTensorde forme(batch_size, config.start_n_top * config.end_n_top), facultatif, renvoyé sistart_positionsouend_positionsn’est pas fourni) — Indices desconfig.start_n_top * config.end_n_topmeilleures possibilités de jetons de fin (beam-search).cls_logits (
torch.Tensorde forme(batch_size,), facultatif, renvoyé sistart_positionsouend_positionsn'est pas fourni) — Probabilités log pour l'étiquetteis_impossibledes réponses.mems (
list[torch.Tensor]de longueurconfig.n_layers) — Contient des états cachés précalculés. Peut être utilisé (voir l’entréemems) pour accélérer le décodage séquentiel. Les identifiants de jetons dont le passé est fourni à ce modèle ne doivent pas être passés en tant queinput_ids, car ils ont déjà été calculés.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé 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, XLNetForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForQuestionAnswering.from_pretrained("xlnet/xlnet-base-cased")
>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
... 0
... ) # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])
>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss