Transformers documentation
FlauBERT
Ce modèle a été publié dans HF papers le 2019-12-11 et ajouté à Hugging Face Transformers le 2020-11-16.
FlauBERT
Aperçu
Le modèle FlauBERT a été proposé dans l'article FlauBERT: Unsupervised Language Model Pre-training for French de Hang Le et al. Il s'agit d'un modèle transformer pré-entraîné à l'aide d'un objectif de modélisation de langage masqué (MLM) (comme BERT).
L'abstract de l'article est le suivant :
Les modèles de langage sont devenus une étape clé pour obtenir des résultats de pointe dans de nombreuses tâches différentes de traitement du langage naturel (NLP). En exploitant la grande quantité de textes non étiquetés disponibles aujourd'hui, ils offrent un moyen efficace de pré-entraîner des représentations continues de mots qui peuvent être affinées pour une tâche aval, ainsi que leur contextualisation au niveau de la phrase. Cela a été largement démontré pour l'anglais à l'aide de représentations contextualisées (Dai and Le, 2015; Peters et al., 2018; Howard and Ruder, 2018; Radford et al., 2018; Devlin et al., 2019; Yang et al., 2019b). Dans cet article, nous introduisons et partageons FlauBERT, un modèle appris sur un corpus français très large et hétérogène. Des modèles de différentes tailles sont entraînés à l'aide du nouveau supercalculateur Jean Zay du CNRS (Centre national de la recherche scientifique). Nous appliquons nos modèles de langage français à diverses tâches de NLP (classification de texte, reformulation, inférence de langage naturel, analyse syntaxique, désambiguïsation du sens des mots) et montrons que, dans la plupart des cas, ils surpassent d'autres approches de pré-entraînement. Différentes versions de FlauBERT, ainsi qu'un protocole d'évaluation unifié pour les tâches aval, appelé FLUE (French Language Understanding Evaluation), sont partagés avec la communauté de recherche pour des expériences reproductibles supplémentaires en NLP français.
Ce modèle a été contribué par formiel. Le code d'origine peut être trouvé ici.
Astuces :
- Comme RoBERTa, sans la prédiction de l'ordre des phrases (donc entraîné uniquement sur l'objectif MLM).
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 masqué
- Guide de la tâche de choix multiples
FlaubertConfig
classe transformers.FlaubertConfig
< 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 = Nonepre_norm: bool = Falselayerdrop: float | int = 0.0vocab_size: int = 30145emb_dim: int = 2048n_layers: int = 12n_heads: int = 16dropout: float | int = 0.1attention_dropout: float | int = 0.1gelu_activation: bool = Truesinusoidal_embeddings: bool = Falsecausal: bool = Falseasm: bool = Falsen_langs: int = 1use_lang_emb: bool = Truemax_position_embeddings: int = 512embed_init_std: float = 0.02209708691207961layer_norm_eps: float = 1e-12init_std: float = 0.02bos_index: int = 0eos_index: int = 1pad_index: int = 2unk_index: int = 3mask_index: int = 5is_encoder: bool = Truesummary_type: str = 'first'summary_use_proj: bool = Truesummary_activation: str | None = Nonesummary_proj_to_labels: bool = Truesummary_first_dropout: float | int = 0.1start_n_top: int = 5end_n_top: int = 5mask_token_id: int = 0lang_id: int = 0pad_token_id: int | None = 2bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 1tie_word_embeddings: bool = True )
Paramètres
- pre_norm (
bool, facultatif, par défautFalse) — Indique si la normalisation de couche doit être appliquée avant ou après la couche feed forward qui suit l'attention dans chaque couche (Vaswani et al., Tensor2Tensor for Neural Machine Translation. 2018) - layerdrop (
Union[float, int], facultatif, par défaut0.0) — La probabilité de LayerDrop. Consultez l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails. - vocab_size (
int, facultatif, par défaut30145) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - emb_dim (
int, facultatif, par défaut 2048) — La dimension de la couche d'embedding. - n_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - n_heads (
int, facultatif, par défaut16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - dropout (
Union[float, int], facultatif, par défaut0.1) — Le taux appliqué à toutes les couches de dropout. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.1) — Le taux de dropout appliqué aux probabilités d'attention. - gelu_activation (
bool, facultatif, valeur par défaut True) — Indique s'il faut utiliser la fonction d'activation GeLU. - sinusoidal_embeddings (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser des embeddings positionnels sinusoïdaux plutôt que des embeddings positionnels absolus. - causal (
bool, facultatif, par défautFalse) — Indique si le modèle doit se comporter de manière causale. Les modèles causaux utilisent un masque d’attention triangulaire afin de ne prêter attention qu’au contexte de gauche, plutôt qu’à un contexte bidirectionnel. - asm (
bool, facultatif, valeur par défautFalse) — Indique s'il faut utiliser une couche de projection log softmax adaptative plutôt qu'une couche linéaire pour la couche de prédiction. - n_langs (
int, facultatif, valeur par défaut 1) — Le nombre de langues gérées par le modèle. Définir à 1 pour les modèles monolingues. - use_lang_emb (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser des embeddings de langue. Certains modèles utilisent des embeddings de langue supplémentaires, consultez la page des modèles multilingues pour des informations sur leur utilisation. - embed_init_std (
float, facultatif, valeur par défaut 2048^-0.5) — L'écart-type de la truncated_normal_initializer pour l'initialisation des matrices d'embedding. - max_position_embeddings (
int, facultatif, par défaut512) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - embed_init_std (
float, facultatif, par défaut2048**-0.5) — Écart-type de l'initialiseur pour les couches d'embedding. - layer_norm_eps (
float, facultatif, valeur par défaut1e-12) — L'épsilon utilisé par les couches de normalisation de couche. - init_std (
float, facultatif, valeur par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - bos_index (
int, facultatif, valeur par défaut 0) — L'index du jeton de début de phrase dans le vocabulaire. - eos_index (
int, facultatif, par défaut 1) — L'index du jeton de fin de phrase dans le vocabulaire. - pad_index (
int, facultatif, valeur par défaut 2) — L'index du jeton de bourrage dans le vocabulaire. - unk_index (
int, facultatif, valeur par défaut : 3) — L'index du jeton inconnu dans le vocabulaire. - mask_index (
int, facultatif, par défaut 5) — L'index du jeton de masquage dans le vocabulaire. - is_encoder (
bool, facultatif, par défaut True) — Indique si le modèle est utilisé comme encodeur. - summary_type (
string, facultatif, par défaut « first ») — Argument utilisé lors de la résumation de séquence. Utilisé dans les modèles de classification de séquence et de choix multiples. 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_proj_to_labels (
bool, facultatif, par défautTrue) — Utilisé dans les modèles de classification de séquences et de choix multiples. Indique si les sorties de la projection doivent avoirconfig.num_labelsouconfig.hidden_sizeclasses. - summary_first_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. - mask_token_id (
int, facultatif, valeur par défaut 0) — Paramètre indépendant du modèle permettant d’identifier les jetons masqués lors de la génération de texte dans un contexte MLM. - lang_id (
int, facultatif, valeur par défaut 1) — L’identifiant de la langue utilisée par le modèle. Ce paramètre est utilisé lors de la génération de texte dans une langue donnée. - pad_token_id (
int, facultatif, par défaut2) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut0) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut1) — 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 FlaubertModel. Elle est utilisée pour instancier un modèle Flaubert 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 flaubert/flaubert_base_uncased
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
FlaubertTokenizer
classe transformers.FlaubertTokenizer
< source >( vocab_filemerges_filedo_lowercase = Falseunk_token = '<unk>'bos_token = '<s>'sep_token = '</s>'pad_token = '<pad>'cls_token = '</s>'mask_token = '<special1>'additional_special_tokens = ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']lang2id = Noneid2lang = None**kwargs )
Paramètres
- vocab_file (
str) — Fichier de vocabulaire. - merges_file (
str) — Fichier de fusions. - do_lowercase (
bool, facultatif, par défautFalse) — Contrôle la conversion en minuscules. - 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. - 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. - sep_token (
str, facultatif, par défaut"</s>") — 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"</s>") — 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"<special1>") — 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['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']) — Liste de jetons spéciaux supplémentaires. - lang2id (
Dict[str, int], facultatif) — Dictionnaire associant les identifiants de langue sous forme de chaînes à leurs identifiants numériques. - id2lang (
Dict[int, str], facultatif) — Dictionnaire associant les identifiants de langue à leurs identifiants sous forme de chaînes de caractères.
Construit un tokenizer Flaubert. Basé sur l'encodage par paires de bytes (Byte-Pair Encoding). Le processus de tokenisation est le suivant :
- Prétraitement et tokenisation Moses.
- Normalisation de tous les textes d'entrée.
- Les arguments
special_tokenset la fonctionset_special_tokenspeuvent être utilisés pour ajouter des symboles supplémentaires (comme ”classify”) à un vocabulaire. - L'argument
do_lowercasecontrôle la conversion en minuscules (définie automatiquement pour les vocabulaires pré-entraînés).
Ce tokenizer hérite de PreTrainedTokenizer, 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.
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: list[int] | None = None ) → List[int]
Paramètres
- token_ids_0 (
List[int]) — Liste des ID auxquels les jetons spéciaux seront ajoutés. - token_ids_1 (
List[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences.
Retourne
List[int]
Liste des identifiants d'entrée avec les jetons spéciaux appropriés.
Construire les entrées du modèle à partir d'une séquence ou d'une paire de séquences pour les tâches de classification de séquences en les concaténant et en ajoutant des jetons spéciaux. Une séquence XLM a le format suivant :
- séquence unique :
<s> X </s> - paire de séquences :
<s> A </s> B </s>
Convertit une séquence de jetons (chaîne de caractères) en une seule chaîne.
get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → List[int]
Paramètres
- token_ids_0 (
List[int]) — Liste d'identifiants. - token_ids_1 (
List[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences. - already_has_special_tokens (
bool, facultatif, par défautFalse) — Indique si la liste de jetons est déjà formatée avec les jetons spéciaux du modèle.
Retourne
List[int]
Une liste d'entiers dans l'intervalle [0, 1] : 1 pour un jeton spécial, 0 pour un jeton de séquence.
Récupère les identifiants de séquences à partir d'une liste de jetons à laquelle aucun jeton spécial n'a été ajouté. Cette méthode est appelée lors de l'ajout de jetons spéciaux à l'aide de la méthode prepare_for_model du tokeniseur.
FlaubertModel
classe transformers.FlaubertModel
< source >( config: FlaubertConfig )
Paramètres
- config (FlaubertConfig) — 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 Flaubert brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonelengths: typing.Optional[torch.LongTensor] = Nonecache: dict[str, torch.FloatTensor] | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutput or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.FloatTensorde 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.
- langs (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Une séquence parallèle de jetons utilisée pour indiquer la langue de chaque jeton de l'entrée. Les indices sont des identifiants de langues, obtenus à partir des noms de langues grâce aux deux mappings de conversion fournis dans la configuration du modèle (uniquement pour les modèles multilingues). Plus précisément, le mapping du nom de langue vers l'identifiant de langue se trouve dansmodel.config.lang2id((qui est un dictionnaire de chaînes vers des entiers) et le mapping de l'identifiant de langue vers le nom de langue se trouve dansmodel.config.id2lang((dictionnaire d'entiers vers des chaînes).Voir des exemples d'utilisation détaillés dans la documentation multilingue.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - lengths (
torch.LongTensorde forme(batch_size,), facultatif) — Longueur de chaque phrase, pouvant être utilisée pour éviter d’appliquer l’attention aux indices des jetons de bourrage. Vous pouvez également utiliserattention_maskpour obtenir le même résultat (voir ci-dessus), conservé ici pour des raisons de compatibilité. Indices sélectionnés dans[0, ..., input_ids.size(-1)]: - cache (
dict[str, torch.FloatTensor], facultatif) — Dictionnaire de chaînes de caractères verstorch.FloatTensorcontenant les états cachés précalculés (clés et valeurs des blocs d’attention) tels que calculés par le modèle (voir la sortiecacheci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. L’objet dictionnaire est modifié en place lors du passage avant pour y ajouter les nouveaux états cachés calculés. - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
BaseModelOutput ou tuple(torch.FloatTensor)
Un BaseModelOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (FlaubertConfig) et des entrées.
La méthode forward de FlaubertModel 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.FloatTensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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.
FlaubertWithLMHeadModel
classe transformers.FlaubertWithLMHeadModel
< source >( config: FlaubertConfig )
Paramètres
- config (FlaubertConfig) — 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 transformer Flaubert avec une tête de modélisation de langage au sommet (couche linéaire dont les poids sont liés aux embeddings 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput or tuple(torch.FloatTensor)
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.
- langs (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Une séquence parallèle de jetons utilisée pour indiquer la langue de chaque jeton de l'entrée. Les indices sont des identifiants de langues, obtenus à partir des noms de langues grâce aux deux mappings de conversion fournis dans la configuration du modèle (uniquement pour les modèles multilingues). Plus précisément, le mapping du nom de langue vers l'identifiant de langue se trouve dansmodel.config.lang2id((qui est un dictionnaire de chaînes vers des entiers) et le mapping de l'identifiant de langue vers le nom de langue se trouve dansmodel.config.id2lang((dictionnaire d'entiers vers des chaînes).Voir des exemples d'utilisation détaillés dans la documentation multilingue.
- 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.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - lengths (
torch.LongTensorde forme(batch_size,), facultatif) — Longueur de chaque phrase, pouvant être utilisée pour éviter d’appliquer l’attention aux indices des jetons de bourrage. Vous pouvez également utiliserattention_maskpour obtenir le même résultat (voir ci-dessus), conservé ici pour des raisons de compatibilité. Indices sélectionnés dans[0, ..., input_ids.size(-1)]: - cache (
dict[str, torch.FloatTensor], facultatif) — Dictionnaire de chaînes de caractères verstorch.FloatTensorcontenant les états cachés précalculés (clés et valeurs des blocs d’attention) tels que calculés par le modèle (voir la sortiecacheci-dessous). Peut être utilisé pour accélérer le décodage séquentiel. L’objet dictionnaire est modifié en place lors du passage avant pour y ajouter les nouveaux états cachés calculés. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le modélisation du langage. Notez que les étiquettes sont décalées à l'intérieur du modèle, c'est-à-dire que vous pouvez définirlabels = input_idsLes indices sont sélectionnés dans[-100, 0, ..., config.vocab_size]Toutes les étiquettes définies sur-100sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans[0, ..., config.vocab_size] - 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
MaskedLMOutput ou tuple(torch.FloatTensor)
Un MaskedLMOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (FlaubertConfig) et des entrées.
La méthode forward de FlaubertWithLMHeadModel 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.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation de langage masquée (MLM).logits (
torch.FloatTensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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 :
>>> import torch
>>> from transformers import AutoTokenizer, FlaubertWithLMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertWithLMHeadModel.from_pretrained("flaubert/flaubert_base_uncased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logitsFlaubertForSequenceClassification
classe transformers.FlaubertForSequenceClassification
< source >( config: FlaubertConfig )
Paramètres
- config (FlaubertConfig) — 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 Flaubert avec une tête de classification/régression de séquences 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SequenceClassifierOutput or tuple(torch.FloatTensor)
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.
- langs (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Une séquence parallèle de jetons utilisée pour indiquer la langue de chaque jeton de l'entrée. Les indices sont des identifiants de langues, obtenus à partir des noms de langues grâce aux deux mappings de conversion fournis dans la configuration du modèle (uniquement pour les modèles multilingues). Plus précisément, le mapping du nom de langue vers l'identifiant de langue se trouve dansmodel.config.lang2id((qui est un dictionnaire de chaînes vers des entiers) et le mapping de l'identifiant de langue vers le nom de langue se trouve dansmodel.config.id2lang((dictionnaire d'entiers vers des chaînes).Voir des exemples d'utilisation détaillés dans la documentation multilingue.
- 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.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - lengths (
torch.LongTensorde forme(batch_size,), facultatif) — Longueur de chaque phrase, pouvant être utilisée pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Vous pouvez également utiliser attention_mask pour obtenir le même résultat (voir ci-dessus), conservé ici pour des raisons de compatibilité. Indices sélectionnés dans[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.FloatTensor], facultatif) — Instance deEncoderDecoderCachecontenant les états KV précalculés. Peut être utilisé pour accélérer le décodage séquentiel. - 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). - 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
SequenceClassifierOutput ou tuple(torch.FloatTensor)
Un SequenceClassifierOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (FlaubertConfig) et des entrées.
La méthode forward de FlaubertForSequenceClassification 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.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.FloatTensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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, FlaubertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased")
>>> 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 = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased", 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, FlaubertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased", 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 = FlaubertForSequenceClassification.from_pretrained(
... "flaubert/flaubert_base_uncased", 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).lossFlaubertForMultipleChoice
classe transformers.FlaubertForMultipleChoice
< source >( config: FlaubertConfig*inputs**kwargs )
Paramètres
- config (FlaubertConfig) — 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 Flaubert 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] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MultipleChoiceModelOutput or tuple(torch.FloatTensor)
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.
- 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.
- langs (
torch.LongTensorde forme(batch_size, num_choices, sequence_length), facultatif) — Une séquence parallèle de jetons utilisée pour indiquer la langue de chaque jeton de l'entrée. Les indices sont des identifiants de langue, obtenus à partir des noms de langue grâce aux deux mappings de conversion fournis dans la configuration du modèle (uniquement pour les modèles multilingues). Plus précisément, le mapping du nom de langue vers l'identifiant de langue se trouve dansmodel.config.lang2id((qui est un dictionnaire de chaînes vers des entiers) et le mapping de l'identifiant de langue vers le nom de langue se trouve dansmodel.config.id2lang((dictionnaire d'entiers vers des chaînes).Voir des exemples d'utilisation détaillés dans la documentation multilingue.
- 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.
- position_ids (
torch.LongTensorde forme(batch_size, num_choices, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - lengths (
torch.LongTensorde forme(batch_size,), facultatif) — Longueur de chaque phrase, pouvant être utilisée pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Vous pouvez également utiliser attention_mask pour obtenir le même résultat (voir ci-dessus), conservé ici pour des raisons de compatibilité. Indices sélectionnés dans[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.FloatTensor], facultatif) — Instance deEncoderDecoderCachecontenant les états KV précalculés. Peut être utilisé pour accélérer le décodage séquentiel. - inputs_embeds (
torch.FloatTensorde 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, ..., num_choices-1]oùnum_choicesest la taille de la deuxième dimension des tenseurs d’entrée. (Voirinput_idsci-dessus) - 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
MultipleChoiceModelOutput ou tuple(torch.FloatTensor)
Un MultipleChoiceModelOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (FlaubertConfig) et des entrées.
La méthode forward de FlaubertForMultipleChoice 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.FloatTensorde forme (1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.FloatTensorde 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).
hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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, FlaubertForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForMultipleChoice.from_pretrained("flaubert/flaubert_base_uncased")
>>> 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.logitsFlaubertForTokenClassification
classe transformers.FlaubertForTokenClassification
< source >( config: FlaubertConfig )
Paramètres
- config (FlaubertConfig) — 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 transformer Flaubert 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → TokenClassifierOutput or tuple(torch.FloatTensor)
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.
- langs (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Une séquence parallèle de jetons utilisée pour indiquer la langue de chaque jeton de l'entrée. Les indices sont des identifiants de langues, obtenus à partir des noms de langues grâce aux deux mappings de conversion fournis dans la configuration du modèle (uniquement pour les modèles multilingues). Plus précisément, le mapping du nom de langue vers l'identifiant de langue se trouve dansmodel.config.lang2id((qui est un dictionnaire de chaînes vers des entiers) et le mapping de l'identifiant de langue vers le nom de langue se trouve dansmodel.config.id2lang((dictionnaire d'entiers vers des chaînes).Voir des exemples d'utilisation détaillés dans la documentation multilingue.
- 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.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - lengths (
torch.LongTensorde forme(batch_size,), facultatif) — Longueur de chaque phrase, pouvant être utilisée pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Vous pouvez également utiliser attention_mask pour obtenir le même résultat (voir ci-dessus), conservé ici pour des raisons de compatibilité. Indices sélectionnés dans[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.FloatTensor], facultatif) — Instance deEncoderDecoderCachecontenant les états KV précalculés. Peut être utilisé pour accélérer le décodage séquentiel. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de classification de jetons. Les indices doivent être dans[0, ..., config.num_labels - 1]. - 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
TokenClassifierOutput ou tuple(torch.FloatTensor)
Un TokenClassifierOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (FlaubertConfig) et des entrées.
La méthode forward de FlaubertForTokenClassification 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.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.FloatTensorde forme(batch_size, sequence_length, config.num_labels)) — Scores de classification (avant SoftMax).hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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, FlaubertForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForTokenClassification.from_pretrained("flaubert/flaubert_base_uncased")
>>> 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)
...FlaubertForQuestionAnsweringSimple
classe transformers.FlaubertForQuestionAnsweringSimple
< source >( config: FlaubertConfig )
Paramètres
- config (FlaubertConfig) — 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 Flaubert avec une tête de classification de segments 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 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → QuestionAnsweringModelOutput or tuple(torch.FloatTensor)
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.
- langs (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Une séquence parallèle de jetons utilisée pour indiquer la langue de chaque jeton de l'entrée. Les indices sont des identifiants de langues, obtenus à partir des noms de langues grâce aux deux mappings de conversion fournis dans la configuration du modèle (uniquement pour les modèles multilingues). Plus précisément, le mapping du nom de langue vers l'identifiant de langue se trouve dansmodel.config.lang2id((qui est un dictionnaire de chaînes vers des entiers) et le mapping de l'identifiant de langue vers le nom de langue se trouve dansmodel.config.id2lang((dictionnaire d'entiers vers des chaînes).Voir des exemples d'utilisation détaillés dans la documentation multilingue.
- 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.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - lengths (
torch.LongTensorde forme(batch_size,), facultatif) — Longueur de chaque phrase, pouvant être utilisée pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Vous pouvez également utiliser attention_mask pour obtenir le même résultat (voir ci-dessus), conservé ici pour des raisons de compatibilité. Indices sélectionnés dans[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.FloatTensor], facultatif) — Instance deEncoderDecoderCachecontenant les états KV précalculés. Peut être utilisé pour accélérer le décodage séquentiel. - 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. - 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
QuestionAnsweringModelOutput ou tuple(torch.FloatTensor)
Un QuestionAnsweringModelOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (FlaubertConfig) et des entrées.
La méthode forward de FlaubertForQuestionAnsweringSimple 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.FloatTensorde 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.FloatTensorde forme(batch_size, sequence_length)) — Scores de début de segment (avant SoftMax).end_logits (
torch.FloatTensorde forme(batch_size, sequence_length)) — Scores de fin de segment (avant SoftMax).hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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, FlaubertForQuestionAnsweringSimple
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForQuestionAnsweringSimple.from_pretrained("flaubert/flaubert_base_uncased")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...FlaubertForQuestionAnswering
classe transformers.FlaubertForQuestionAnswering
< source >( config: FlaubertConfig )
Paramètres
- config (FlaubertConfig) — 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 transformer Flaubert 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] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = 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] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → FlaubertForQuestionAnsweringOutput or tuple(torch.FloatTensor)
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.
- langs (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Une séquence parallèle de jetons utilisée pour indiquer la langue de chaque jeton de l'entrée. Les indices sont des identifiants de langues, obtenus à partir des noms de langues grâce aux deux mappings de conversion fournis dans la configuration du modèle (uniquement pour les modèles multilingues). Plus précisément, le mapping du nom de langue vers l'identifiant de langue se trouve dansmodel.config.lang2id((qui est un dictionnaire de chaînes vers des entiers) et le mapping de l'identifiant de langue vers le nom de langue se trouve dansmodel.config.id2lang((dictionnaire d'entiers vers des chaînes).Voir des exemples d'utilisation détaillés dans la documentation multilingue.
- 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.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - lengths (
torch.LongTensorde forme(batch_size,), facultatif) — Longueur de chaque phrase, pouvant être utilisée pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Vous pouvez également utiliser attention_mask pour obtenir le même résultat (voir ci-dessus), conservé ici pour des raisons de compatibilité. Indices sélectionnés dans[0, ..., input_ids.size(-1)]. - cache (
dict[str, torch.FloatTensor], facultatif) — Instance deEncoderDecoderCachecontenant les états KV précalculés. Peut être utilisé pour accélérer le décodage séquentiel. - 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.FloatTensorde 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é. - 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
FlaubertForQuestionAnsweringOutput ou tuple(torch.FloatTensor)
Un FlaubertForQuestionAnsweringOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments en fonction de la configuration (FlaubertConfig) et des entrées.
La méthode forward de FlaubertForQuestionAnswering 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.FloatTensorde forme(1,), facultatif, renvoyé sistart_positionsetend_positionssont tous deux fournis) — Perte de classification correspondant à la somme des pertes de classification des jetons de début, de fin (et de is_impossible si fourni).start_top_log_probs (
torch.FloatTensorde 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 (beam-search).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.FloatTensorde 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.FloatTensorde forme(batch_size,), facultatif, renvoyé sistart_positionsouend_positionsn'est pas fourni) — Probabilités log pour l'étiquetteis_impossibledes réponses.hidden_states (
tuple[torch.FloatTensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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, FlaubertForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = FlaubertForQuestionAnswering.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> 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