Transformers documentation

BART

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Ce modèle a été publié dans HF papers le 2019-10-29 et ajouté à Hugging Face Transformers le 2020-11-16.

BART

BART est un modèle séquence-à-séquence qui combine les objectifs de pré-entraînement de BERT et de GPT. Il est pré-entraîné en corrompant le texte de différentes manières, comme supprimer des mots, mélanger des phrases ou masquer des jetons, et en apprenant à le réparer. L’encodeur encode le document corrompu et le texte corrompu est corrigé par le décodeur. En apprenant à récupérer le texte d’origine, BART devient très performant à la fois pour comprendre et générer le langage.

Vous pouvez trouver tous les points de contrôle BART originaux sous l'organisation AI at Meta.

L'exemple ci-dessous montre comment prédire le jeton [MASK] avec Pipeline, AutoModel et depuis la ligne de commande.

Pipeline

AutoModel

Notes

Les entrées doivent être remplies à droite car BART utilise des embeddings de position absolus.
Le point de contrôle facebook/bart-large-cnn n’inclut pas mask_token_id, ce qui signifie qu’il ne peut pas effectuer de tâches de remplissage de masque.
BART n’utilise pas token_type_ids pour la classification de séquences. Utilisez BartTokenizer ou encode() pour obtenir le découpage approprié.
Le passage avant de BartModel crée les decoder_input_ids s’ils ne sont pas fournis. Cela peut différer des API d’autres modèles, mais c’est une fonctionnalité utile pour les tâches de remplissage de masques.
Les prédictions du modèle sont censées être identiques à celles de l'implémentation d'origine lorsque forced_bos_token_id=0. Cela ne fonctionne que si le texte transmis à fairseq.encode commence par un espace.
generate() doit être utilisé pour les tâches de génération conditionnelle telles que la résumés.

BartConfig

classe transformers.BartConfig

< source >

Paramètres

is_encoder_decoder (bool, facultatif, valeur par défaut True) — Indique si le modèle est utilisé comme encodeur/décodeur ou non.
vocab_size (int, facultatif, par défaut 50265) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
max_position_embeddings (int, facultatif, par défaut 1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
encoder_layers (int, facultatif, valeur par défaut 12) — Nombre de couches cachées dans l’encodeur Transformer. Utilise la même valeur que num_layers si non défini.
encoder_ffn_dim (int, facultatif, par défaut 4096) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) de l’encodeur.
encoder_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.
decoder_layers (int, facultatif, valeur par défaut 12) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que num_layers si non défini.
decoder_ffn_dim (int, facultatif, valeur par défaut 4096) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.
decoder_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
encoder_layerdrop (float, facultatif, par défaut 0.0) — Probabilité de LayerDrop pour l’encodeur. Voir l’article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
decoder_layerdrop (float, facultatif, par défaut 0.0) — Probabilité de LayerDrop pour le décodeur. Voir l’article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
activation_function (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
d_model (int, facultatif, par défaut 1024) — Taille des couches encodeur et de la couche pooler.
dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
activation_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée.
init_std (float, facultatif, valeur par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
classifier_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout pour le classifieur.
scale_embedding (bool, facultatif, par défaut False) — Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model).
use_cache (bool, facultatif, valeur par défaut True) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
pad_token_id (int, facultatif, par défaut 1) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
bos_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
eos_token_id (Union[int, list[int]], facultatif, par défaut 2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
decoder_start_token_id (int, facultatif, valeur par défaut 2) — Si un modèle encodeur-décodeur commence le décodage avec un jeton différent de bos, l’identifiant de ce jeton.
forced_eos_token_id (Union[int, list[int]], facultatif, par défaut 2) — L’identifiant du jeton à forcer comme dernier jeton généré lorsque max_length est atteint. Généralement défini sur eos_token_id.
is_decoder (bool, facultatif, par défaut False) — Indique si le modèle est utilisé comme décodeur ou non. Si False, le modèle est utilisé comme encodeur.
tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un BartModel. Elle est utilisée pour instancier un modèle Bart 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 facebook/bart-large

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.

Exemple :

>>> from transformers import BartConfig, BartModel

>>> # Initializing a BART facebook/bart-large style configuration
>>> configuration = BartConfig()

>>> # Initializing a model (with random weights) from the facebook/bart-large style configuration
>>> model = BartModel(configuration)

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

BartTokenizer

classe transformers.RobertaTokenizer

< source >

( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneerrors: str = 'replace'bos_token: str = '<s>'eos_token: str = '</s>'sep_token: str = '</s>'cls_token: str = '<s>'unk_token: str = '<unk>'pad_token: str = '<pad>'mask_token: str = '<mask>'add_prefix_space: bool = Falsetrim_offsets: bool = True**kwargs )

Paramètres

vocab (str, dict ou list, facultatif) — Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis vocab_file.
merges (str ou list, facultatif) — Liste de fusions personnalisée. Si non fournie, les fusions sont chargées depuis merges_file.
errors (str, facultatif, par défaut "replace") — Paradigme à suivre lors du décodage des octets en UTF-8. Voir bytes.decode pour plus d'informations.
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.
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.
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.
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.
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.
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.
add_prefix_space (bool, facultatif, valeur par défaut False) — Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot. (Le tokenizer RoBERTa détecte le début des mots par l'espace qui les précède).
trim_offsets (bool, facultatif, par défaut True) — Indique si l'étape de post-traitement doit rogner les décalages afin d'éviter d'inclure des espaces.

Construit un tokenizer RoBERTa (basé sur la bibliothèque tokenizers de HuggingFace). Basé sur l'encodage par paires de bytes (Byte-Pair-Encoding).

Ce tokenizer a été entraîné à traiter les espaces comme des parties des jetons (un peu comme sentencepiece), de sorte qu'un mot sera

être encodé différemment selon qu'il se trouve au début de la phrase (sans espace) ou non :

>>> from transformers import RobertaTokenizer

>>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

Vous pouvez contourner ce comportement en passant add_prefix_space=True lors de l’instanciation de ce tokenizer ou lors de son appel sur un texte, mais comme le modèle n’a pas été pré-entraîné de cette manière, cela pourrait entraîner une baisse des performances.

Lorsqu'il est utilisé avec is_split_into_words=True, ce tokenizer doit être instancié avec add_prefix_space=True.

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.

BartTokenizerFast

classe transformers.RobertaTokenizer

< source >

Paramètres

vocab (str, dict ou list, facultatif) — Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis vocab_file.
merges (str ou list, facultatif) — Liste de fusions personnalisée. Si non fournie, les fusions sont chargées depuis merges_file.
errors (str, facultatif, par défaut "replace") — Paradigme à suivre lors du décodage des octets en UTF-8. Voir bytes.decode pour plus d'informations.
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.
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.
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.
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.
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.
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.
add_prefix_space (bool, facultatif, valeur par défaut False) — Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot. (Le tokenizer RoBERTa détecte le début des mots par l'espace qui les précède).
trim_offsets (bool, facultatif, par défaut True) — Indique si l'étape de post-traitement doit rogner les décalages afin d'éviter d'inclure des espaces.

Construit un tokenizer RoBERTa (basé sur la bibliothèque tokenizers de HuggingFace). Basé sur l'encodage par paires de bytes (Byte-Pair-Encoding).

Ce tokenizer a été entraîné à traiter les espaces comme des parties des jetons (un peu comme sentencepiece), de sorte qu'un mot sera

être encodé différemment selon qu'il se trouve au début de la phrase (sans espace) ou non :

>>> from transformers import RobertaTokenizer

>>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

Lorsqu'il est utilisé avec is_split_into_words=True, ce tokenizer doit être instancié avec add_prefix_space=True.

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.

BartModel

classe transformers.BartModel

< source >

( config: BartConfig )

Paramètres

config (BartConfig) — 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 Bart 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.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: list[torch.FloatTensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput or tuple(torch.FloatTensor)

Paramètres

input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Qu'est-ce que les identifiants d'entrée ?
attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
Qu'est-ce que les masques d'attention ?
decoder_input_ids (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? Bart utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values). Pour l'entraînement à la traduction et à la résumation, decoder_input_ids doit être fourni. Si aucun decoder_input_ids n'est fourni, le modèle créera ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l'article.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Quelles sont les identifiants d'entrée du décodeur ?

Bart utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n’entrer que le dernier decoder_input_ids (voir past_key_values).

Pour l’entraînement à la traduction et à la résumée, decoder_input_ids doit être fourni. Si aucun decoder_input_ids n’est fourni, le modèle crée ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l’article.
decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans decoder_input_ids. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire modeling_bart._prepare_decoder_attention_mask et le modifier selon vos besoins. Consultez la figure 1 de l'article pour plus d'informations sur la stratégie par défaut.
Si vous souhaitez modifier le comportement du padding, vous devez lire modeling_bart._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article pour plus d’informations sur la stratégie par défaut.
encoder_outputs (list[torch.FloatTensor], facultatif) — Tuple composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur.
past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.
Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

Le modèle produira le même format de cache qui est fourni en entrée.

Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).
inputs_embeds (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
decoder_inputs_embeds (torch.FloatTensor de forme (batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer decoder_input_ids vous pouvez choisir de passer directement une représentation intégrée. Si past_key_values est utilisé, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.
Si decoder_input_ids et decoder_inputs_embeds sont tous deux non définis, decoder_inputs_embeds prend la valeur de inputs_embeds.
use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqModelOutput ou tuple(torch.FloatTensor)

Un Seq2SeqModelOutput 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 (BartConfig) et des entrées.

La méthode forward de BartModel redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.

Si past_key_values est utilisé, seule la dernière hidden-state des séquences de forme (batch_size, 1, hidden_size) est renvoyée.
past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.

Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.
decoder_hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 décodeur à la sortie de chaque couche, plus les sorties d'incorporation initiale facultatives.
decoder_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
encoder_hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 de l'encodeur à la sortie de chaque couche, plus les sorties d'incorporation initiales facultatives.
encoder_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

BartForConditionalGeneration

classe transformers.BartForConditionalGeneration

< source >

( config: BartConfig )

Paramètres

config (BartConfig) — 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 BART avec une tête de modélisation de langage. Peut être utilisé pour la résumation.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: list[torch.FloatTensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.FloatTensor)

Paramètres

input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Qu'est-ce que les identifiants d'entrée ?
attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
Qu'est-ce que les masques d'attention ?
decoder_input_ids (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? Bart utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values). Pour l'entraînement à la traduction et à la résumation, decoder_input_ids doit être fourni. Si aucun decoder_input_ids n'est fourni, le modèle créera ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l'article.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Quelles sont les identifiants d'entrée du décodeur ?

Bart utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n’entrer que le dernier decoder_input_ids (voir past_key_values).

Pour l’entraînement à la traduction et à la résumée, decoder_input_ids doit être fourni. Si aucun decoder_input_ids n’est fourni, le modèle crée ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l’article.
decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans decoder_input_ids. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire modeling_bart._prepare_decoder_attention_mask et le modifier selon vos besoins. Consultez la figure 1 de l'article pour plus d'informations sur la stratégie par défaut.
Si vous souhaitez modifier le comportement du padding, vous devez lire modeling_bart._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article pour plus d’informations sur la stratégie par défaut.
encoder_outputs (list[torch.FloatTensor], facultatif) — Tuple composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur.
past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.
Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

Le modèle produira le même format de cache qui est fourni en entrée.

Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).
inputs_embeds (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
decoder_inputs_embeds (torch.FloatTensor de forme (batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer decoder_input_ids vous pouvez choisir de passer directement une représentation intégrée. Si past_key_values est utilisé, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.
Si decoder_input_ids et decoder_inputs_embeds sont tous deux non définis, decoder_inputs_embeds prend la valeur de inputs_embeds.
labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans [0, ..., config.vocab_size] ou -100 (voir la docstring de input_ids). Les jetons dont l'indice est défini sur -100 sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans [0, ..., config.vocab_size].
use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqLMOutput ou tuple(torch.FloatTensor)

Un Seq2SeqLMOutput 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 (BartConfig) et des entrées.

La méthode forward de BartForConditionalGeneration redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

loss (torch.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage.
logits (torch.FloatTensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.

Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.
decoder_hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
encoder_hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple de résumés :

>>> from transformers import AutoTokenizer, BartForConditionalGeneration

>>> model = BartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")

>>> ARTICLE_TO_SUMMARIZE = (
...     "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
...     "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
...     "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
... )
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=1024, return_tensors="pt")

>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"], num_beams=2, min_length=0, max_length=20)
>>> tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
'PG&E scheduled the blackouts in response to forecasts for high winds amid dry conditions'

Exemple de remplissage de masque :

>>> from transformers import AutoTokenizer, BartForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-base")
>>> model = BartForConditionalGeneration.from_pretrained("facebook/bart-base")

>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> logits = model(input_ids).logits

>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = logits[0, masked_index].softmax(dim=0)
>>> values, predictions = probs.topk(5)

>>> tokenizer.decode(predictions).split()
['not', 'good', 'healthy', 'great', 'very']

BartForSequenceClassification

classe transformers.BartForSequenceClassification

< source >

( config: BartConfig**kwargs )

Paramètres

config (BartConfig) — 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 Bart avec une tête de classification de séquence au sommet (une couche linéaire au-dessus de la sortie agrégée), par exemple pour les tâches GLUE.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: list[torch.FloatTensor] | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqSequenceClassifierOutput or tuple(torch.FloatTensor)

Paramètres

input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Qu'est-ce que les identifiants d'entrée ?
attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
Qu'est-ce que les masques d'attention ?
decoder_input_ids (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? Bart utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values). Pour l'entraînement à la traduction et à la résumation, decoder_input_ids doit être fourni. Si aucun decoder_input_ids n'est fourni, le modèle créera ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l'article.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Quelles sont les identifiants d'entrée du décodeur ?

Bart utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n’entrer que le dernier decoder_input_ids (voir past_key_values).

Pour l’entraînement à la traduction et à la résumée, decoder_input_ids doit être fourni. Si aucun decoder_input_ids n’est fourni, le modèle crée ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l’article.
decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans decoder_input_ids. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire modeling_bart._prepare_decoder_attention_mask et le modifier selon vos besoins. Consultez la figure 1 de l'article pour plus d'informations sur la stratégie par défaut.
Si vous souhaitez modifier le comportement du padding, vous devez lire modeling_bart._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article pour plus d’informations sur la stratégie par défaut.
encoder_outputs (list[torch.FloatTensor], facultatif) — Tuple composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur.
inputs_embeds (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
decoder_inputs_embeds (torch.FloatTensor de forme (batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer decoder_input_ids vous pouvez choisir de passer directement une représentation intégrée. Si past_key_values est utilisé, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.
Si decoder_input_ids et decoder_inputs_embeds sont tous deux non définis, decoder_inputs_embeds prend la valeur de inputs_embeds.
labels (torch.LongTensor de 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]. Si config.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Si config.num_labels > 1, une perte de classification est calculée (entropie croisée).
use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqSequenceClassifierOutput ou tuple(torch.FloatTensor)

Un Seq2SeqSequenceClassifierOutput 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 (BartConfig) et des entrées.

La méthode forward de BartForSequenceClassification redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

loss (torch.FloatTensor de forme (1,), facultatif, renvoyé lorsque label est fourni) — Perte de classification (ou de régression si config.num_labels==1).
logits (torch.FloatTensor de forme (batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).
past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.

Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.
decoder_hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
encoder_hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de l'encodeur, 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, BartForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large")
>>> model = BartForSequenceClassification.from_pretrained("facebook/bart-large")

>>> 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 = BartForSequenceClassification.from_pretrained("facebook/bart-large", 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, BartForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large")
>>> model = BartForSequenceClassification.from_pretrained("facebook/bart-large", 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 = BartForSequenceClassification.from_pretrained(
...     "facebook/bart-large", 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).loss

BartForQuestionAnswering

classe transformers.BartForQuestionAnswering

< source >

( config: BartConfig )

Paramètres

config (BartConfig) — 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 Bart 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-dessus de la sortie des états cachés pour calculer span start logits et span end logits).

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: list[torch.FloatTensor] | None = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

Paramètres

input_ids (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Qu'est-ce que les identifiants d'entrée ?
attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
Qu'est-ce que les masques d'attention ?
decoder_input_ids (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? Bart utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values). Pour l'entraînement à la traduction et à la résumation, decoder_input_ids doit être fourni. Si aucun decoder_input_ids n'est fourni, le modèle créera ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l'article.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Quelles sont les identifiants d'entrée du décodeur ?

Bart utilise eos_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n’entrer que le dernier decoder_input_ids (voir past_key_values).

Pour l’entraînement à la traduction et à la résumée, decoder_input_ids doit être fourni. Si aucun decoder_input_ids n’est fourni, le modèle crée ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l’article.
decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans decoder_input_ids. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire modeling_bart._prepare_decoder_attention_mask et le modifier selon vos besoins. Consultez la figure 1 de l'article pour plus d'informations sur la stratégie par défaut.
Si vous souhaitez modifier le comportement du padding, vous devez lire modeling_bart._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article pour plus d’informations sur la stratégie par défaut.
encoder_outputs (list[torch.FloatTensor], facultatif) — Tuple composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur.
start_positions (torch.LongTensor de 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 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.
end_positions (torch.LongTensor de 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.
inputs_embeds (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
decoder_inputs_embeds (torch.FloatTensor de forme (batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer decoder_input_ids vous pouvez choisir de passer directement une représentation intégrée. Si past_key_values est utilisé, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.
Si decoder_input_ids et decoder_inputs_embeds sont tous deux non définis, decoder_inputs_embeds prend la valeur de inputs_embeds.
use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqQuestionAnsweringModelOutput ou tuple(torch.FloatTensor)

Un Seq2SeqQuestionAnsweringModelOutput 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 (BartConfig) et des entrées.

La méthode forward de BartForQuestionAnswering redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

loss (torch.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est 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.FloatTensor de forme (batch_size, sequence_length)) — Scores de début de segment (avant SoftMax).
end_logits (torch.FloatTensor de forme (batch_size, sequence_length)) — Scores de fin de segment (avant SoftMax).
past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.

Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.
decoder_hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
encoder_hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de l'encodeur, 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, BartForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large")
>>> model = BartForQuestionAnswering.from_pretrained("facebook/bart-large")

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

BartForCausalLM

classe transformers.BartForCausalLM

< source >

( config: BartConfig )

Paramètres

config (BartConfig) — 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.

Décodeur BART 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).

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.FloatTensor] = Noneencoder_attention_mask: typing.Optional[torch.FloatTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

Paramètres

input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Qu'est-ce que les identifiants d'entrée ?
attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
Qu'est-ce que les masques d'attention ?
encoder_hidden_states (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée si le modèle est configuré comme un décodeur.
encoder_attention_mask (torch.FloatTensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'effectuer l'attention sur les indices des jetons de bourrage de l'entrée de l'encodeur. Ce masque est utilisé dans l'attention croisée si le modèle est configuré comme un décodeur. Valeurs du masque sélectionnées dans [0, 1]:
- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.
Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

Le modèle produira le même format de cache qui est fourni en entrée.

Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).
inputs_embeds (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans [0, ..., config.vocab_size] ou -100 (voir la docstring de input_ids). Les jetons dont l'indice est défini sur -100 sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans [0, ..., config.vocab_size].
use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
logits_to_keep (Union[int, torch.Tensor], facultatif, valeur par défaut 0) — Si c'est un int, calcule les logits pour les logits_to_keep derniers jetons. Si 0, calcule les logits pour tous les input_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 un torch.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

CausalLMOutputWithCrossAttentions ou tuple(torch.FloatTensor)

Un CausalLMOutputWithCrossAttentions 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 (BartConfig) et des entrées.

La méthode forward de BartForCausalLM redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

loss (torch.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).
logits (torch.FloatTensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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é lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.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.
cross_attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids des attentions croisées après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.

Contient des états cachés précalculés (clés et valeurs dans les blocs d'attention) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

Exemple :

>>> from transformers import AutoTokenizer, BartForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-base")
>>> model = BartForCausalLM.from_pretrained("facebook/bart-base")
>>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size]
>>> list(logits.shape) == expected_shape
True

Update on GitHub

←Bamba BARThez→